@swaggerexpert/jsonpath 1.0.0

package/es/index.mjs

@@ -0,0 +1,4 @@
+export { default as Grammar } from "./grammar.mjs";
+export { default as parse } from "./parse/index.mjs";
+export { default as JSONPathQueryCST } from "./parse/ast/JSONPathQueryCST.mjs";
+export { default as translateEvaluator } from "./parse/evaluators/translate.mjs";

package/es/parse/ast/JSONPathQueryCST.mjs

@@ -0,0 +1,96 @@
+import { Ast as AST } from 'apg-lite';
+import cstCallback from "../callbacks/cst.mjs";
+class JSONPathQueryCST extends AST {
+  constructor() {
+    super();
+
+    // https://www.rfc-editor.org/rfc/rfc9535#section-2.1.1
+    this.callbacks['jsonpath-query'] = cstCallback('jsonpath-query');
+    this.callbacks['segments'] = cstCallback('segments');
+    this.callbacks['B'] = cstCallback('text');
+    this.callbacks['S'] = cstCallback('text');
+
+    // https://www.rfc-editor.org/rfc/rfc9535#section-2.2.1
+    this.callbacks['root-identifier'] = cstCallback('root-identifier');
+
+    // https://www.rfc-editor.org/rfc/rfc9535#section-2.3
+    this.callbacks['selector'] = cstCallback('selector');
+
+    // https://www.rfc-editor.org/rfc/rfc9535#section-2.3.1.1
+    this.callbacks['name-selector'] = cstCallback('name-selector');
+    this.callbacks['string-literal'] = cstCallback('string-literal');
+    this.callbacks['double-quoted'] = cstCallback('double-quoted');
+    this.callbacks['single-quoted'] = cstCallback('single-quoted');
+
+    // https://www.rfc-editor.org/rfc/rfc9535#section-2.3.2.1
+    this.callbacks['wildcard-selector'] = cstCallback('wildcard-selector');
+
+    // https://www.rfc-editor.org/rfc/rfc9535#section-2.3.3.1
+    this.callbacks['index-selector'] = cstCallback('index-selector');
+
+    // https://www.rfc-editor.org/rfc/rfc9535#section-2.3.4.1
+    this.callbacks['slice-selector'] = cstCallback('slice-selector');
+    this.callbacks['start'] = cstCallback('start');
+    this.callbacks['end'] = cstCallback('end');
+    this.callbacks['step'] = cstCallback('step');
+
+    // https://www.rfc-editor.org/rfc/rfc9535#section-2.3.5.1
+    this.callbacks['filter-selector'] = cstCallback('filter-selector');
+    this.callbacks['logical-expr'] = cstCallback('logical-expr');
+    this.callbacks['logical-or-expr'] = cstCallback('logical-or-expr');
+    this.callbacks['logical-and-expr'] = cstCallback('logical-and-expr');
+    this.callbacks['basic-expr'] = cstCallback('basic-expr');
+    this.callbacks['paren-expr'] = cstCallback('paren-expr');
+    this.callbacks['logical-not-op'] = cstCallback('logical-not-op');
+    this.callbacks['test-expr'] = cstCallback('test-expr');
+    this.callbacks['filter-query'] = cstCallback('filter-query');
+    this.callbacks['rel-query'] = cstCallback('rel-query');
+    this.callbacks['current-node-identifier'] = cstCallback('current-node-identifier');
+    this.callbacks['comparison-expr'] = cstCallback('comparison-expr');
+    this.callbacks['literal'] = cstCallback('literal');
+    this.callbacks['comparable'] = cstCallback('comparable');
+    this.callbacks['comparison-op'] = cstCallback('comparison-op');
+    this.callbacks['singular-query'] = cstCallback('singular-query');
+    this.callbacks['rel-singular-query'] = cstCallback('rel-singular-query');
+    this.callbacks['abs-singular-query'] = cstCallback('abs-singular-query');
+    this.callbacks['singular-query-segments'] = cstCallback('singular-query-segments');
+    this.callbacks['name-segment'] = cstCallback('name-segment');
+    this.callbacks['index-segment'] = cstCallback('index-segment');
+    this.callbacks['number'] = cstCallback('number');
+    this.callbacks['true'] = cstCallback('true');
+    this.callbacks['false'] = cstCallback('false');
+    this.callbacks['null'] = cstCallback('null');
+
+    // https://www.rfc-editor.org/rfc/rfc9535#section-2.4
+    this.callbacks['function-name'] = cstCallback('function-name');
+    this.callbacks['function-expr'] = cstCallback('function-expr');
+    this.callbacks['function-argument'] = cstCallback('function-argument');
+
+    // https://www.rfc-editor.org/rfc/rfc9535#section-2.5
+    this.callbacks['segment'] = cstCallback('segment');
+
+    // https://www.rfc-editor.org/rfc/rfc9535#section-2.5.1.1
+    this.callbacks['child-segment'] = cstCallback('child-segment');
+    this.callbacks['bracketed-selection'] = cstCallback('bracketed-selection');
+    this.callbacks['member-name-shorthand'] = cstCallback('member-name-shorthand');
+
+    // https://www.rfc-editor.org/rfc/rfc9535#section-2.5.2.1
+    this.callbacks['descendant-segment'] = cstCallback('descendant-segment');
+
+    // Surrogate named rules
+    this.callbacks['dot-prefix'] = cstCallback('text');
+    this.callbacks['double-dot-prefix'] = cstCallback('text');
+    this.callbacks['left-bracket'] = cstCallback('text');
+    this.callbacks['right-bracket'] = cstCallback('text');
+    this.callbacks['comma'] = cstCallback('text');
+    this.callbacks['colon'] = cstCallback('text');
+    this.callbacks['dquote'] = cstCallback('text');
+    this.callbacks['squote'] = cstCallback('text');
+    this.callbacks['questionmark'] = cstCallback('text');
+    this.callbacks['disjunction'] = cstCallback('text');
+    this.callbacks['conjunction'] = cstCallback('text');
+    this.callbacks['left-paren'] = cstCallback('text');
+    this.callbacks['right-paren'] = cstCallback('text');
+  }
+}
+export default JSONPathQueryCST;

package/es/parse/callbacks/cst.mjs

@@ -0,0 +1,39 @@
+import { utilities, identifiers } from 'apg-lite';
+import JSONPathParseError from "../../errors/JSONPathParseError.mjs";
+const cst = ruleName => {
+  return (state, chars, phraseIndex, phraseLength, data) => {
+    if (!(typeof data === 'object' && data !== null && !Array.isArray(data))) {
+      throw new JSONPathParseError("parser's user data must be an object");
+    }
+    if (!data.stack) {
+      data.stack = [];
+      data.root = null;
+    }
+
+    // drop the empty nodes
+    if (phraseLength === 0) return;
+    if (state === identifiers.SEM_PRE) {
+      const node = {
+        type: ruleName,
+        text: utilities.charsToString(chars, phraseIndex, phraseLength),
+        start: phraseIndex,
+        length: phraseLength,
+        children: []
+      };
+      if (data.stack.length > 0) {
+        const parent = data.stack[data.stack.length - 1];
+        const isTextWithinTextNode = parent.type === 'text' && node.type === 'text';
+        if (!isTextWithinTextNode) {
+          parent.children.push(node);
+        }
+      } else {
+        data.root = node;
+      }
+      data.stack.push(node);
+    }
+    if (state === identifiers.SEM_POST) {
+      data.stack.pop();
+    }
+  };
+};
+export default cst;

package/es/parse/evaluators/translate.mjs

@@ -0,0 +1,9 @@
+const translateEvaluator = (ast, {
+  result
+}) => {
+  if (!result.success) return null;
+  const parts = {};
+  ast.translate(parts);
+  return parts;
+};
+export default translateEvaluator;

package/es/parse/index.mjs

@@ -0,0 +1,33 @@
+import { Parser } from 'apg-lite';
+import Grammar from "../grammar.mjs";
+import translateEvaluator from "./evaluators/translate.mjs";
+import JSONPathQueryCST from "./ast/JSONPathQueryCST.mjs";
+import JSONPathParseError from "../errors/JSONPathParseError.mjs";
+const grammar = new Grammar();
+const parse = (jsonPath, {
+  ast = new JSONPathQueryCST(),
+  evaluator = translateEvaluator
+} = {}) => {
+  if (typeof jsonPath !== 'string') {
+    throw new TypeError('JSONPath must be a string');
+  }
+  try {
+    const parser = new Parser();
+    parser.ast = ast;
+    const result = parser.parse(grammar, 'jsonpath-query', jsonPath);
+    const computed = evaluator(ast, {
+      result
+    });
+    return {
+      result,
+      ast,
+      computed
+    };
+  } catch (error) {
+    throw new JSONPathParseError('Unexpected error during JSONPath parsing', {
+      cause: error,
+      jsonPath
+    });
+  }
+};
+export default parse;

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@swaggerexpert/jsonpath",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "1.0.0",
+  "description": "RCF 9535 implementation of JSONPath",
+  "main": "./cjs/index.cjs",
+  "types": "./types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./es/index.mjs",
+      "require": "./cjs/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "watch": {
+    "test": "{src,test}/*.js"
+  },
+  "scripts": {
+    "prepublishOnly": "npm run build",
+    "grammar:compile": "node ./scripts/apg-js.js --lite --in=./src/grammar.bnf --out=./src/grammar.js && cd ./src",
+    "build": "npm run grammar:compile && npm run build:es && npm run build:cjs && npm run build:cjs:apg-lite",
+    "build:es": "cross-env BABEL_ENV=es babel src --out-dir es --extensions '.js' --out-file-extension '.mjs'",
+    "build:cjs": "cross-env BABEL_ENV=cjs babel src --out-dir cjs --extensions '.js' --out-file-extension '.cjs'",
+    "build:cjs:apg-lite": "cross-env BABEL_ENV=cjs babel node_modules/apg-lite/lib/parser.js --out-file ./cjs/apg-lite.cjs",
+    "test": "cross-env UPDATE_SNAPSHOT=new mocha",
+    "test:watch": "npm-watch test",
+    "watch": "npm-watch"
+  },
+  "engines": {
+    "node": ">=12.20.0"
+  },
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/swaggerexpert/jsonpath.git"
+  },
+  "keywords": [
+    "jsonpath",
+    "parser",
+    "validator",
+    "rfc9535"
+  ],
+  "author": "Vladimír Gorej <vladimir.gorej@gmail.com>",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/swaggerexpert/jsonpath/issues"
+  },
+  "homepage": "https://github.com/swaggerexpert/jsonpath#readme",
+  "files": [
+    "es/",
+    "cjs/",
+    "types/",
+    "LICENSE",
+    "NOTICE",
+    "package.json",
+    "README.md",
+    "SECURITY.md"
+  ],
+  "dependencies": {
+    "apg-lite": "^1.0.4"
+  },
+  "devDependencies": {
+    "@babel/cli": "=7.26.4",
+    "@babel/core": "=7.26.10",
+    "@babel/preset-env": "=7.26.9",
+    "@commitlint/cli": "=19.8.0",
+    "@commitlint/config-conventional": "=19.8.0",
+    "apg-js": "^4.4.0",
+    "babel-plugin-module-resolver": "^5.0.2",
+    "chai": "=5.2.0",
+    "cross-env": "^7.0.3",
+    "husky": "=9.1.7",
+    "mocha": "=11.1.0",
+    "mocha-expect-snapshot": "^7.2.0",
+    "npm-watch": "^0.13.0",
+    "prettier": "^3.5.2"
+  }
+}

package/types/index.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Parsing
+ */
+export function parse(jsonpath: string, options?: ParseOptions): ParseResult;
+
+export interface ParseOptions {
+  readonly ast?: AST;
+}
+
+export interface AST {
+  readonly translate: (parts: Record<string, CSTNode>) => Record<string, CSTNode>;
+  readonly toXml: () => string;
+}
+
+export interface ParseResult {
+  readonly result: {
+    readonly success: boolean;
+  };
+  readonly ast: AST;
+  readonly computed: Record<string, CSTNode>;
+}
+
+export interface CSTNode {
+  type: string,
+  text: string,
+  start: number,
+  length: number,
+  children: CSTNode[],
+}
+
+/**
+ * Grammar
+ */
+export function Grammar(): Grammar;
+
+export interface Grammar {
+  grammarObject: string; // Internal identifier
+  rules: Rule[]; // List of grammar rules
+  udts: UDT[]; // User-defined terminals (empty in this grammar)
+  toString(): string; // Method to return the grammar in ABNF format
+}
+
+export interface Rule {
+  name: string; // Rule name
+  lower: string; // Lowercased rule name
+  index: number; // Rule index
+  isBkr: boolean; // Is this a back-reference?
+  opcodes?: Opcode[]; // List of opcodes for the rule
+}
+
+export type Opcode =
+  | { type: 1; children: number[] } // ALT (alternation)
+  | { type: 2; children: number[] } // CAT (concatenation)
+  | { type: 3; min: number; max: number } // REP (repetition)
+  | { type: 4; index: number } // RNM (rule reference)
+  | { type: 5; min: number; max: number } // TRG (terminal range)
+  | { type: 6 | 7; string: number[] }; // TBS or TLS (byte sequence or literal string)
+
+export type UDT = {}; // User-defined terminals (empty in this grammar)