@swaggerexpert/arazzo-runtime-expression 1.0.0 → 2.0.1

package/es/index.mjs

@@ -1,4 +1,10 @@
-export { default as Grammar } from "./runtime-expression.mjs";
+export { default as Grammar } from "./grammar.mjs";
 export { default as extract } from "./extract.mjs";
-export { default as test } from "./test.mjs";
-export { default as parse } from "./parse/index.mjs";
+export { default as parse } from "./parse/index.mjs";
+export { default as CSTTranslator } from "./parse/translators/CSTTranslator.mjs";
+export { default as XMLTranslator } from "./parse/translators/XMLTranslator.mjs";
+export { default as ASTTranslator } from "./parse/translators/ASTTranslator/index.mjs";
+export { default as Trace } from "./parse/trace/Trace.mjs";
+export { default as test } from "./test/index.mjs";
+export { default as ArazzoRuntimeExpressionError } from "./errors/ArazzoRuntimeExpressionError.mjs";
+export { default as ArazzoRuntimeExpressionParseError } from "./errors/ArazzoRuntimeExpressionParseError.mjs";

package/es/parse/callbacks/cst.mjs

@@ -0,0 +1,24 @@
+import { utilities, identifiers } from 'apg-lite';
+const cst = nodeType => {
+  return (state, chars, phraseIndex, phraseLength, data) => {
+    if (state === identifiers.SEM_PRE) {
+      const node = {
+        type: nodeType,
+        text: utilities.charsToString(chars, phraseIndex, phraseLength),
+        start: phraseIndex,
+        length: phraseLength,
+        children: []
+      };
+      if (data.stack.length > 0) {
+        data.stack[data.stack.length - 1].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/index.mjs

@@ -1,35 +1,34 @@
-import { Ast as AST, Parser } from 'apg-lite';
-import Grammar from "../runtime-expression.mjs";
-import expressionCallback from "./callbacks/expression.mjs";
-import parameterNameCallback from "./callbacks/parameter-name.mjs";
-import sourceCallback from "./callbacks/source.mjs";
-import headerReferenceCallback from "./callbacks/header-reference.mjs";
-import queryReferenceCallback from "./callbacks/query-reference.mjs";
-import pathReferenceCallback from "./callbacks/path-reference.mjs";
-import bodyReferenceCallback from "./callbacks/body-reference.mjs";
-import jsonPointerCallback from "./callbacks/json-pointer.mjs";
-import referenceTokenCallback from "./callbacks/reference-token.mjs";
-import nameCallback from "./callbacks/name.mjs";
-import tokenCallback from "./callbacks/token.mjs";
+import { Parser, Stats } from 'apg-lite';
+import Grammar from "../grammar.mjs";
+import ASTTranslator from "./translators/ASTTranslator/index.mjs";
+import Trace from "./trace/Trace.mjs";
+import ArazzoRuntimeExpressionParseError from "../errors/ArazzoRuntimeExpressionParseError.mjs";
 const grammar = new Grammar();
-const parse = runtimeExpression => {
-  const parser = new Parser();
-  parser.ast = new AST();
-  parser.ast.callbacks.expression = expressionCallback;
-  parser.ast.callbacks['parameter-name'] = parameterNameCallback;
-  parser.ast.callbacks.source = sourceCallback;
-  parser.ast.callbacks['header-reference'] = headerReferenceCallback;
-  parser.ast.callbacks['query-reference'] = queryReferenceCallback;
-  parser.ast.callbacks['path-reference'] = pathReferenceCallback;
-  parser.ast.callbacks['body-reference'] = bodyReferenceCallback;
-  parser.ast.callbacks['json-pointer'] = jsonPointerCallback;
-  parser.ast.callbacks['reference-token'] = referenceTokenCallback;
-  parser.ast.callbacks.name = nameCallback;
-  parser.ast.callbacks.token = tokenCallback;
-  const result = parser.parse(grammar, 'expression', runtimeExpression);
-  return {
-    result,
-    ast: parser.ast
-  };
+const parse = (runtimeExpression, {
+  stats = false,
+  trace = false,
+  translator = new ASTTranslator()
+} = {}) => {
+  if (typeof runtimeExpression !== 'string') {
+    throw new TypeError('Runtime expression must be a string');
+  }
+  try {
+    const parser = new Parser();
+    if (translator) parser.ast = translator;
+    if (stats) parser.stats = new Stats();
+    if (trace) parser.trace = new Trace();
+    const result = parser.parse(grammar, 'expression', runtimeExpression);
+    return {
+      result,
+      tree: result.success && translator ? parser.ast.getTree() : undefined,
+      stats: parser.stats,
+      trace: parser.trace
+    };
+  } catch (error) {
+    throw new ArazzoRuntimeExpressionParseError('Unexpected error during Arazzo Runtime Expression parsing', {
+      cause: error,
+      runtimeExpression
+    });
+  }
 };
 export default parse;

package/es/parse/trace/Expectations.mjs

@@ -0,0 +1,6 @@
+class Expectations extends Array {
+  toString() {
+    return this.map(c => `"${String(c)}"`).join(', ');
+  }
+}
+export default Expectations;

package/es/parse/trace/Trace.mjs

@@ -0,0 +1,30 @@
+import { Trace as BaseTrace } from 'apg-lite';
+import Expectations from "./Expectations.mjs";
+class Trace extends BaseTrace {
+  inferExpectations() {
+    const lines = this.displayTrace().split('\n');
+    const expectations = new Set();
+    let lastMatchedIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+
+      // capture the max match line (first one that ends in a single character match)
+      if (line.includes('M|')) {
+        const textMatch = line.match(/]'(.*)'$/);
+        if (textMatch && textMatch[1]) {
+          lastMatchedIndex = i;
+        }
+      }
+
+      // collect terminal failures after the deepest successful match
+      if (i > lastMatchedIndex) {
+        const terminalFailMatch = line.match(/N\|\[TLS\(([^)]+)\)]/);
+        if (terminalFailMatch) {
+          expectations.add(terminalFailMatch[1]);
+        }
+      }
+    }
+    return new Expectations(...expectations);
+  }
+}
+export default Trace;

package/es/parse/translators/ASTTranslator/index.mjs

@@ -0,0 +1,9 @@
+import CSTTranslator from "../CSTTranslator.mjs";
+import transformers, { transformCSTtoAST } from "./transformers.mjs";
+class ASTTranslator extends CSTTranslator {
+  getTree() {
+    const cst = super.getTree();
+    return transformCSTtoAST(cst, transformers);
+  }
+}
+export default ASTTranslator;

package/es/parse/translators/ASTTranslator/transformers.mjs

@@ -0,0 +1,219 @@
+import { Parser } from 'apg-lite';
+import Grammar from "../../../grammar.mjs";
+import CSTTranslator from "../CSTTranslator.mjs";
+const grammar = new Grammar();
+const parseStepsName = stepsName => {
+  const parser = new Parser();
+  parser.ast = new CSTTranslator();
+  const result = parser.parse(grammar, 'steps-name', stepsName);
+  if (!result.success) {
+    throw new Error(`Invalid steps expression name: ${stepsName}`);
+  }
+  return parser.ast.getTree();
+};
+const parseWorkflowsName = workflowsName => {
+  const parser = new Parser();
+  parser.ast = new CSTTranslator();
+  const result = parser.parse(grammar, 'workflows-name', workflowsName);
+  if (!result.success) {
+    throw new Error(`Invalid workflows expression name: ${workflowsName}`);
+  }
+  return parser.ast.getTree();
+};
+const parseSourceDescriptionsName = sourceDescriptionsName => {
+  const parser = new Parser();
+  parser.ast = new CSTTranslator();
+  const result = parser.parse(grammar, 'source-descriptions-name', sourceDescriptionsName);
+  if (!result.success) {
+    throw new Error(`Invalid source descriptions expression name: ${sourceDescriptionsName}`);
+  }
+  return parser.ast.getTree();
+};
+const parseComponentsName = componentsName => {
+  const parser = new Parser();
+  parser.ast = new CSTTranslator();
+  const result = parser.parse(grammar, 'components-name', componentsName);
+  if (!result.success) {
+    throw new Error(`Invalid components expression name: ${componentsName}`);
+  }
+  return parser.ast.getTree();
+};
+export const transformCSTtoAST = (node, transformerMap) => {
+  const transformer = transformerMap[node.type];
+  if (!transformer) {
+    throw new Error(`No transformer for CST node type: ${node.type}`);
+  }
+  return transformer(node);
+};
+const transformers = {
+  ['expression'](node) {
+    const text = node.text;
+
+    // Literal expressions
+    if (text === '$url') return {
+      type: 'UrlExpression'
+    };
+    if (text === '$method') return {
+      type: 'MethodExpression'
+    };
+    if (text === '$statusCode') return {
+      type: 'StatusCodeExpression'
+    };
+
+    // Source expressions (request/response)
+    if (text.startsWith('$request.')) {
+      const sourceNode = node.children.find(c => c.type === 'source');
+      return {
+        type: 'RequestExpression',
+        source: transformCSTtoAST(sourceNode, transformers)
+      };
+    }
+    if (text.startsWith('$response.')) {
+      const sourceNode = node.children.find(c => c.type === 'source');
+      return {
+        type: 'ResponseExpression',
+        source: transformCSTtoAST(sourceNode, transformers)
+      };
+    }
+
+    // Named expressions (raw name)
+    const nameNode = node.children.find(c => c.type === 'name');
+    if (text.startsWith('$inputs.')) {
+      return {
+        type: 'InputsExpression',
+        name: nameNode.text
+      };
+    }
+    if (text.startsWith('$outputs.')) {
+      return {
+        type: 'OutputsExpression',
+        name: nameNode.text
+      };
+    }
+    if (text.startsWith('$steps.')) {
+      const stepsNameCST = parseStepsName(nameNode.text);
+      return transformCSTtoAST(stepsNameCST, transformers);
+    }
+    if (text.startsWith('$workflows.')) {
+      const workflowsNameCST = parseWorkflowsName(nameNode.text);
+      return transformCSTtoAST(workflowsNameCST, transformers);
+    }
+    if (text.startsWith('$sourceDescriptions.')) {
+      const sourceDescriptionsNameCST = parseSourceDescriptionsName(nameNode.text);
+      return transformCSTtoAST(sourceDescriptionsNameCST, transformers);
+    }
+    if (text.startsWith('$components.')) {
+      const componentsNameCST = parseComponentsName(nameNode.text);
+      return transformCSTtoAST(componentsNameCST, transformers);
+    }
+  },
+  ['source'](node) {
+    const child = node.children[0];
+    return {
+      type: 'Source',
+      reference: transformCSTtoAST(child, transformers)
+    };
+  },
+  ['header-reference'](node) {
+    const tokenNode = node.children.find(c => c.type === 'token');
+    return {
+      type: 'HeaderReference',
+      token: tokenNode.text.toLowerCase()
+    };
+  },
+  ['query-reference'](node) {
+    const nameNode = node.children.find(c => c.type === 'name');
+    return {
+      type: 'QueryReference',
+      name: nameNode.text
+    };
+  },
+  ['path-reference'](node) {
+    const nameNode = node.children.find(c => c.type === 'name');
+    return {
+      type: 'PathReference',
+      name: nameNode.text
+    };
+  },
+  ['body-reference'](node) {
+    const jsonPointerNode = node.children.find(c => c.type === 'json-pointer');
+    if (!jsonPointerNode) {
+      return {
+        type: 'BodyReference'
+      };
+    }
+    return {
+      type: 'BodyReference',
+      jsonPointer: transformCSTtoAST(jsonPointerNode, transformers)
+    };
+  },
+  ['json-pointer'](node) {
+    const referenceTokens = node.children.filter(c => c.type === 'reference-token').map(c => transformCSTtoAST(c, transformers));
+    return {
+      type: 'JsonPointer',
+      value: node.text,
+      referenceTokens
+    };
+  },
+  ['reference-token'](node) {
+    return {
+      type: 'ReferenceToken',
+      value: node.text
+    };
+  },
+  // steps-name secondary grammar transformers
+  ['steps-name'](node) {
+    const stepIdNode = node.children.find(c => c.type === 'steps-id');
+    const fieldNode = node.children.find(c => c.type === 'steps-field');
+    const subFieldNode = node.children.find(c => c.type === 'steps-sub-field');
+    const jsonPointerNode = node.children.find(c => c.type === 'json-pointer');
+    const result = {
+      type: 'StepsExpression',
+      stepId: stepIdNode.text,
+      field: fieldNode.text,
+      outputName: subFieldNode.text
+    };
+    if (jsonPointerNode) {
+      result.jsonPointer = transformCSTtoAST(jsonPointerNode, transformers);
+    }
+    return result;
+  },
+  // workflows-name secondary grammar transformers
+  ['workflows-name'](node) {
+    const workflowIdNode = node.children.find(c => c.type === 'workflows-id');
+    const fieldNode = node.children.find(c => c.type === 'workflows-field');
+    const subFieldNode = node.children.find(c => c.type === 'workflows-sub-field');
+    const jsonPointerNode = node.children.find(c => c.type === 'json-pointer');
+    const result = {
+      type: 'WorkflowsExpression',
+      workflowId: workflowIdNode.text,
+      field: fieldNode.text,
+      subField: subFieldNode.text
+    };
+    if (jsonPointerNode) {
+      result.jsonPointer = transformCSTtoAST(jsonPointerNode, transformers);
+    }
+    return result;
+  },
+  // source-descriptions-name secondary grammar transformers
+  ['source-descriptions-name'](node) {
+    const sourceNameNode = node.children.find(c => c.type === 'source-descriptions-source-name');
+    const referenceNode = node.children.find(c => c.type === 'source-descriptions-reference');
+    return {
+      type: 'SourceDescriptionsExpression',
+      sourceName: sourceNameNode.text,
+      reference: referenceNode.text
+    };
+  },
+  // components-name secondary grammar transformers
+  ['components-name'](node) {
+    const fieldNode = node.children.find(c => c.type === 'components-field');
+    const subFieldNode = node.children.find(c => c.type === 'components-sub-field');
+    return {
+      type: 'ComponentsExpression',
+      field: fieldNode.text,
+      subField: subFieldNode.text
+    };
+  }
+};
+export default transformers;

package/es/parse/translators/CSTTranslator.mjs

@@ -0,0 +1,50 @@
+import { Ast as AST } from 'apg-lite';
+import cstCallback from "../callbacks/cst.mjs";
+class CSTTranslator extends AST {
+  constructor() {
+    super();
+
+    // expression-string grammar rules
+    this.callbacks['expression-string'] = cstCallback('expression-string');
+    this.callbacks['embedded-expression'] = cstCallback('embedded-expression');
+    this.callbacks['literal-char'] = cstCallback('literal-char');
+    // main expression grammar rules
+    this.callbacks['expression'] = cstCallback('expression');
+    this.callbacks['source'] = cstCallback('source');
+    this.callbacks['header-reference'] = cstCallback('header-reference');
+    this.callbacks['query-reference'] = cstCallback('query-reference');
+    this.callbacks['path-reference'] = cstCallback('path-reference');
+    this.callbacks['body-reference'] = cstCallback('body-reference');
+    this.callbacks['json-pointer'] = cstCallback('json-pointer');
+    this.callbacks['reference-token'] = cstCallback('reference-token');
+    this.callbacks['name'] = cstCallback('name');
+    this.callbacks['token'] = cstCallback('token');
+    // steps-name secondary grammar rules
+    this.callbacks['steps-name'] = cstCallback('steps-name');
+    this.callbacks['steps-id'] = cstCallback('steps-id');
+    this.callbacks['steps-field'] = cstCallback('steps-field');
+    this.callbacks['steps-sub-field'] = cstCallback('steps-sub-field');
+    // workflows-name secondary grammar rules
+    this.callbacks['workflows-name'] = cstCallback('workflows-name');
+    this.callbacks['workflows-id'] = cstCallback('workflows-id');
+    this.callbacks['workflows-field'] = cstCallback('workflows-field');
+    this.callbacks['workflows-sub-field'] = cstCallback('workflows-sub-field');
+    // source-descriptions-name secondary grammar rules
+    this.callbacks['source-descriptions-name'] = cstCallback('source-descriptions-name');
+    this.callbacks['source-descriptions-source-name'] = cstCallback('source-descriptions-source-name');
+    this.callbacks['source-descriptions-reference'] = cstCallback('source-descriptions-reference');
+    // components-name secondary grammar rules
+    this.callbacks['components-name'] = cstCallback('components-name');
+    this.callbacks['components-field'] = cstCallback('components-field');
+    this.callbacks['components-sub-field'] = cstCallback('components-sub-field');
+  }
+  getTree() {
+    const data = {
+      stack: [],
+      root: null
+    };
+    this.translate(data);
+    return data.root;
+  }
+}
+export default CSTTranslator;

package/es/parse/translators/XMLTranslator.mjs

@@ -0,0 +1,7 @@
+import CSTTranslator from "./CSTTranslator.mjs";
+class XMLTranslator extends CSTTranslator {
+  getTree() {
+    return this.toXml();
+  }
+}
+export default XMLTranslator;

package/es/test/index.mjs

@@ -0,0 +1,13 @@
+import parse from "../parse/index.mjs";
+const test = runtimeExpression => {
+  if (typeof runtimeExpression !== 'string') return false;
+  try {
+    const {
+      result
+    } = parse(runtimeExpression);
+    return result.success;
+  } catch {
+    return false;
+  }
+};
+export default test;

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.0.0",
+  "version": "2.0.1",
   "description": "Arazzo Runtime expressions parser, validator and extractor.",
   "main": "./cjs/index.cjs",
   "types": "./types/index.d.ts",
@@ -20,17 +20,17 @@
   },
   "scripts": {
     "prepublishOnly": "npm run build",
-    "grammar:compile": "node ./scripts/apg-js.js --lite --in=./src/runtime-expression.bnf --out=./src/runtime-expression.js && cd ./src",
+    "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": "mocha",
+    "test": "cross-env UPDATE_SNAPSHOT=new mocha",
     "test:watch": "npm-watch test",
     "watch": "npm-watch"
   },
   "engines": {
-    "node": ">=12.20.0"
+    "node": ">=16.14.0"
   },
   "type": "module",
   "repository": {
@@ -62,21 +62,28 @@
     "SECURITY.md"
   ],
   "dependencies": {
-    "apg-lite": "^1.0.4"
+    "apg-lite": "^1.0.5"
   },
   "devDependencies": {
-    "@babel/cli": "=7.26.4",
-    "@babel/core": "=7.26.9",
-    "@babel/preset-env": "=7.26.9",
-    "@commitlint/cli": "=19.7.1",
-    "@commitlint/config-conventional": "=19.7.1",
+    "@babel/cli": "=7.28.6",
+    "@babel/core": "=7.28.6",
+    "@babel/preset-env": "=7.28.6",
+    "@commitlint/cli": "=20.3.1",
+    "@commitlint/config-conventional": "=20.3.1",
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^12.0.2",
+    "@semantic-release/npm": "^13.1.3",
+    "@semantic-release/release-notes-generator": "^14.1.0",
     "apg-js": "^4.4.0",
     "babel-plugin-module-resolver": "^5.0.2",
-    "chai": "=5.2.0",
-    "cross-env": "^7.0.3",
+    "chai": "=6.2.2",
+    "cross-env": "^10.0.0",
     "husky": "=9.1.7",
-    "mocha": "=11.1.0",
+    "mocha": "=11.7.5",
+    "mocha-expect-snapshot": "^8.0.0",
     "npm-watch": "^0.13.0",
-    "prettier": "^3.1.1"
+    "prettier": "^3.1.1",
+    "semantic-release": "^25.0.2"
   }
 }