@swaggerexpert/arazzo-criterion 1.0.0

package/cjs/index.cjs

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "ASTTranslator", {
+  enumerable: true,
+  get: function () {
+    return _index4.default;
+  }
+});
+Object.defineProperty(exports, "ArazzoCriterionError", {
+  enumerable: true,
+  get: function () {
+    return _ArazzoCriterionError.default;
+  }
+});
+Object.defineProperty(exports, "ArazzoCriterionEvaluateError", {
+  enumerable: true,
+  get: function () {
+    return _ArazzoCriterionEvaluateError.default;
+  }
+});
+Object.defineProperty(exports, "ArazzoCriterionParseError", {
+  enumerable: true,
+  get: function () {
+    return _ArazzoCriterionParseError.default;
+  }
+});
+Object.defineProperty(exports, "CSTTranslator", {
+  enumerable: true,
+  get: function () {
+    return _CSTTranslator.default;
+  }
+});
+Object.defineProperty(exports, "Grammar", {
+  enumerable: true,
+  get: function () {
+    return _grammar.default;
+  }
+});
+Object.defineProperty(exports, "Trace", {
+  enumerable: true,
+  get: function () {
+    return _Trace.default;
+  }
+});
+Object.defineProperty(exports, "XMLTranslator", {
+  enumerable: true,
+  get: function () {
+    return _XMLTranslator.default;
+  }
+});
+Object.defineProperty(exports, "evaluate", {
+  enumerable: true,
+  get: function () {
+    return _index3.default;
+  }
+});
+Object.defineProperty(exports, "parse", {
+  enumerable: true,
+  get: function () {
+    return _index.default;
+  }
+});
+Object.defineProperty(exports, "test", {
+  enumerable: true,
+  get: function () {
+    return _index2.default;
+  }
+});
+var _grammar = _interopRequireDefault(require("./grammar.cjs"));
+var _index = _interopRequireDefault(require("./parse/index.cjs"));
+var _index2 = _interopRequireDefault(require("./test/index.cjs"));
+var _index3 = _interopRequireDefault(require("./evaluate/index.cjs"));
+var _CSTTranslator = _interopRequireDefault(require("./parse/translators/CSTTranslator.cjs"));
+var _index4 = _interopRequireDefault(require("./parse/translators/ASTTranslator/index.cjs"));
+var _XMLTranslator = _interopRequireDefault(require("./parse/translators/XMLTranslator.cjs"));
+var _Trace = _interopRequireDefault(require("./parse/trace/Trace.cjs"));
+var _ArazzoCriterionError = _interopRequireDefault(require("./errors/ArazzoCriterionError.cjs"));
+var _ArazzoCriterionParseError = _interopRequireDefault(require("./errors/ArazzoCriterionParseError.cjs"));
+var _ArazzoCriterionEvaluateError = _interopRequireDefault(require("./errors/ArazzoCriterionEvaluateError.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }

package/cjs/parse/callbacks/cst.cjs

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _apgLite = require("../../apg-lite.cjs");
+const cst = nodeType => {
+  return (state, chars, phraseIndex, phraseLength, data) => {
+    if (state === _apgLite.identifiers.SEM_PRE) {
+      const node = {
+        type: nodeType,
+        text: _apgLite.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 === _apgLite.identifiers.SEM_POST) {
+      data.stack.pop();
+    }
+  };
+};
+var _default = exports.default = cst;

package/cjs/parse/index.cjs

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _apgLite = require("../apg-lite.cjs");
+var _grammar = _interopRequireDefault(require("../grammar.cjs"));
+var _index = _interopRequireDefault(require("./translators/ASTTranslator/index.cjs"));
+var _Trace = _interopRequireDefault(require("./trace/Trace.cjs"));
+var _ArazzoCriterionParseError = _interopRequireDefault(require("../errors/ArazzoCriterionParseError.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const grammar = new _grammar.default();
+const parse = (condition, {
+  startRule = 'condition',
+  stats = false,
+  trace = false,
+  translator = new _index.default()
+} = {}) => {
+  if (typeof condition !== 'string') {
+    throw new TypeError('Criterion condition must be a string');
+  }
+  try {
+    const parser = new _apgLite.Parser();
+    if (translator) parser.ast = translator;
+    if (stats) parser.stats = new _apgLite.Stats();
+    if (trace) parser.trace = new _Trace.default();
+    const result = parser.parse(grammar, startRule, condition);
+    return {
+      result,
+      tree: result.success && translator ? parser.ast.getTree() : undefined,
+      stats: parser.stats,
+      trace: parser.trace
+    };
+  } catch (error) {
+    throw new _ArazzoCriterionParseError.default('Unexpected error during Arazzo Criterion parsing', {
+      cause: error,
+      condition
+    });
+  }
+};
+var _default = exports.default = parse;

package/cjs/parse/trace/Expectations.cjs

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+class Expectations extends Array {
+  toString() {
+    return this.map(c => `"${String(c)}"`).join(', ');
+  }
+}
+var _default = exports.default = Expectations;

package/cjs/parse/trace/Trace.cjs

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _apgLite = require("../../apg-lite.cjs");
+var _Expectations = _interopRequireDefault(require("./Expectations.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class Trace extends _apgLite.Trace {
+  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.default(...expectations);
+  }
+}
+var _default = exports.default = Trace;

package/cjs/parse/translators/ASTTranslator/index.cjs

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _CSTTranslator = _interopRequireDefault(require("../CSTTranslator.cjs"));
+var _transformers = _interopRequireWildcard(require("./transformers.cjs"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class ASTTranslator extends _CSTTranslator.default {
+  getTree() {
+    const cst = super.getTree();
+    return (0, _transformers.transformCSTtoAST)(cst, _transformers.default);
+  }
+}
+var _default = exports.default = ASTTranslator;

package/cjs/parse/translators/ASTTranslator/transformers.cjs

@@ -0,0 +1,203 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.transformCSTtoAST = exports.default = void 0;
+var _arazzoRuntimeExpression = require("@swaggerexpert/arazzo-runtime-expression");
+var _index = _interopRequireDefault(require("../../index.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+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);
+};
+
+// A basic-expr is not a registered CST rule, so its alternatives
+// (paren-expr / comparison-expr / test-expr) and the literal alternatives
+// (number / string / boolean / null) surface directly as children.
+exports.transformCSTtoAST = transformCSTtoAST;
+const OPERAND_TYPES = new Set(['paren-expr', 'comparison-expr', 'test-expr', 'runtime-expression-operand', 'number', 'string', 'boolean', 'null']);
+
+/**
+ * Split an operand token at the boundary between its runtime-expression base and the
+ * trailing criterion navigation, returning both as text. The base is the longest
+ * leading substring that parses as a runtime expression.
+ *
+ * The grammar cannot find this boundary itself - a runtime expression and the
+ * criterion accessors both use "." - so it is resolved here by delegating to
+ * @swaggerexpert/arazzo-runtime-expression.
+ */
+const splitAtRuntimeExpression = operand => {
+  const full = (0, _arazzoRuntimeExpression.parse)(operand);
+  if (full.result.success) {
+    return {
+      expressionText: operand,
+      navigationText: ''
+    };
+  }
+
+  // A failing parse reports how far it matched; walk down from there to the
+  // longest prefix that parses cleanly (robust against stopping mid-rule).
+  for (let n = full.result.maxMatched; n > 0; n -= 1) {
+    if ((0, _arazzoRuntimeExpression.parse)(operand.slice(0, n)).result.success) {
+      return {
+        expressionText: operand.slice(0, n),
+        navigationText: operand.slice(n)
+      };
+    }
+  }
+  throw new Error(`Operand is not a valid runtime expression: "${operand}"`);
+};
+
+/**
+ * Parse a criterion navigation remainder (e.g. ".data[0].id") into a MemberAccess /
+ * IndexAccess path by parsing it against the grammar's `runtime-expression-navigation`
+ * rule (a secondary entry point); the ASTTranslator produces the path array directly.
+ * Throws if the remainder is not a valid accessor sequence.
+ */
+const parseNavigation = navigationText => {
+  const {
+    result,
+    tree
+  } = (0, _index.default)(navigationText, {
+    startRule: 'runtime-expression-navigation'
+  });
+  if (!result.success) {
+    throw new Error(`Invalid criterion navigation: "${navigationText}"`);
+  }
+  return tree;
+};
+
+/**
+ * Parse an operand token into its runtime-expression base and criterion navigation,
+ * both already parsed. `navigation` is an empty array when there are no accessors.
+ */
+const parseOperand = operand => {
+  const {
+    expressionText,
+    navigationText
+  } = splitAtRuntimeExpression(operand);
+  const runtimeExpression = {
+    type: 'RuntimeExpression',
+    text: expressionText,
+    expression: (0, _arazzoRuntimeExpression.parse)(expressionText).tree
+  };
+  const navigation = navigationText === '' ? [] : parseNavigation(navigationText);
+  return {
+    runtimeExpression,
+    navigation
+  };
+};
+const foldLeftAssociative = (operands, operator) => operands.reduce((left, right) => ({
+  type: 'LogicalExpression',
+  operator,
+  left,
+  right
+}));
+const transformers = {
+  ['condition'](node) {
+    const child = node.children.find(c => c.type === 'logical-or-expr');
+    return transformCSTtoAST(child, transformers);
+  },
+  ['logical-or-expr'](node) {
+    const operands = node.children.filter(c => c.type === 'logical-and-expr').map(c => transformCSTtoAST(c, transformers));
+    return operands.length === 1 ? operands[0] : foldLeftAssociative(operands, '||');
+  },
+  ['logical-and-expr'](node) {
+    const operands = node.children.filter(c => OPERAND_TYPES.has(c.type)).map(c => transformCSTtoAST(c, transformers));
+    return operands.length === 1 ? operands[0] : foldLeftAssociative(operands, '&&');
+  },
+  ['paren-expr'](node) {
+    const inner = node.children.find(c => c.type === 'logical-or-expr');
+    const argument = transformCSTtoAST(inner, transformers);
+    const negated = node.children.some(c => c.type === 'logical-not-op');
+    return negated ? {
+      type: 'UnaryExpression',
+      operator: '!',
+      argument
+    } : argument;
+  },
+  ['test-expr'](node) {
+    const operandNode = node.children.find(c => OPERAND_TYPES.has(c.type));
+    const argument = transformCSTtoAST(operandNode, transformers);
+    const negated = node.children.some(c => c.type === 'logical-not-op');
+    return negated ? {
+      type: 'UnaryExpression',
+      operator: '!',
+      argument
+    } : argument;
+  },
+  ['comparison-expr'](node) {
+    const operands = node.children.filter(c => OPERAND_TYPES.has(c.type));
+    const opNode = node.children.find(c => c.type === 'comparison-op');
+    return {
+      type: 'BinaryExpression',
+      operator: opNode.text,
+      left: transformCSTtoAST(operands[0], transformers),
+      right: transformCSTtoAST(operands[1], transformers)
+    };
+  },
+  ['runtime-expression-operand'](node) {
+    const {
+      runtimeExpression,
+      navigation
+    } = parseOperand(node.text);
+    if (navigation.length === 0) return runtimeExpression;
+    return {
+      type: 'RuntimeExpressionNavigation',
+      expression: runtimeExpression,
+      navigation
+    };
+  },
+  ['runtime-expression-navigation'](node) {
+    return node.children.filter(c => c.type === 'member-access' || c.type === 'index-access').map(c => transformCSTtoAST(c, transformers));
+  },
+  ['member-access'](node) {
+    const nameNode = node.children.find(c => c.type === 'member-name');
+    return {
+      type: 'MemberAccess',
+      name: nameNode.text
+    };
+  },
+  ['index-access'](node) {
+    const indexNode = node.children.find(c => c.type === 'index');
+    return {
+      type: 'IndexAccess',
+      value: Number(indexNode.text)
+    };
+  },
+  ['number'](node) {
+    return {
+      type: 'Literal',
+      valueType: 'number',
+      value: Number(node.text)
+    };
+  },
+  ['string'](node) {
+    // strip surrounding single quotes, then collapse doubled '' into a single '
+    const inner = node.text.slice(1, -1).replace(/''/g, "'");
+    return {
+      type: 'Literal',
+      valueType: 'string',
+      value: inner
+    };
+  },
+  ['boolean'](node) {
+    return {
+      type: 'Literal',
+      valueType: 'boolean',
+      value: node.text === 'true'
+    };
+  },
+  ['null'](node) {
+    return {
+      type: 'Literal',
+      valueType: 'null',
+      value: null
+    };
+  }
+};
+var _default = exports.default = transformers;

package/cjs/parse/translators/CSTTranslator.cjs

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _apgLite = require("../../apg-lite.cjs");
+var _cst = _interopRequireDefault(require("../callbacks/cst.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class CSTTranslator extends _apgLite.Ast {
+  constructor() {
+    super();
+
+    // logical / comparison spine
+    this.callbacks['condition'] = (0, _cst.default)('condition');
+    this.callbacks['logical-or-expr'] = (0, _cst.default)('logical-or-expr');
+    this.callbacks['logical-and-expr'] = (0, _cst.default)('logical-and-expr');
+    this.callbacks['paren-expr'] = (0, _cst.default)('paren-expr');
+    this.callbacks['comparison-expr'] = (0, _cst.default)('comparison-expr');
+    this.callbacks['test-expr'] = (0, _cst.default)('test-expr');
+    this.callbacks['logical-not-op'] = (0, _cst.default)('logical-not-op');
+    this.callbacks['comparison-op'] = (0, _cst.default)('comparison-op');
+
+    // comparable operand (runtime expression + navigation), captured as one token
+    this.callbacks['runtime-expression-operand'] = (0, _cst.default)('runtime-expression-operand');
+
+    // navigation (secondary entry point; parses the accessor remainder of an operand)
+    this.callbacks['runtime-expression-navigation'] = (0, _cst.default)('runtime-expression-navigation');
+    this.callbacks['member-access'] = (0, _cst.default)('member-access');
+    this.callbacks['index-access'] = (0, _cst.default)('index-access');
+    this.callbacks['member-name'] = (0, _cst.default)('member-name');
+    this.callbacks['index'] = (0, _cst.default)('index');
+
+    // literals
+    this.callbacks['number'] = (0, _cst.default)('number');
+    this.callbacks['string'] = (0, _cst.default)('string');
+    this.callbacks['boolean'] = (0, _cst.default)('boolean');
+    this.callbacks['null'] = (0, _cst.default)('null');
+  }
+  getTree() {
+    const data = {
+      stack: [],
+      root: null
+    };
+    this.translate(data);
+    return data.root;
+  }
+}
+var _default = exports.default = CSTTranslator;

package/cjs/parse/translators/XMLTranslator.cjs

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _CSTTranslator = _interopRequireDefault(require("./CSTTranslator.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class XMLTranslator extends _CSTTranslator.default {
+  getTree() {
+    return this.toXml();
+  }
+}
+var _default = exports.default = XMLTranslator;

package/cjs/test/index.cjs

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _index = _interopRequireDefault(require("../parse/index.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const test = condition => {
+  if (typeof condition !== 'string') return false;
+  try {
+    const {
+      result
+    } = (0, _index.default)(condition);
+    return result.success;
+  } catch {
+    return false;
+  }
+};
+var _default = exports.default = test;

package/es/errors/ArazzoCriterionError.mjs

@@ -0,0 +1,40 @@
+class ArazzoCriterionError extends Error {
+  constructor(message, options = undefined) {
+    super(message, options);
+    this.name = this.constructor.name;
+    if (typeof message === 'string') {
+      this.message = message;
+    }
+    if (typeof Error.captureStackTrace === 'function') {
+      Error.captureStackTrace(this, this.constructor);
+    } else {
+      this.stack = new Error(message).stack;
+    }
+
+    /**
+     * This needs to stay here until our minimum supported version of Node.js is >= 16.9.0.
+     * Node.js is >= 16.9.0 supports error causes natively.
+     */
+    if (options != null && typeof options === 'object' && Object.hasOwn(options, 'cause') && !('cause' in this)) {
+      const {
+        cause
+      } = options;
+      this.cause = cause;
+      if (cause instanceof Error && 'stack' in cause) {
+        this.stack = `${this.stack}\nCAUSE: ${cause.stack}`;
+      }
+    }
+
+    /**
+     * Allows to assign arbitrary properties to the error object.
+     */
+    if (options != null && typeof options === 'object') {
+      const {
+        cause,
+        ...causelessOptions
+      } = options;
+      Object.assign(this, causelessOptions);
+    }
+  }
+}
+export default ArazzoCriterionError;

package/es/errors/ArazzoCriterionEvaluateError.mjs

@@ -0,0 +1,3 @@
+import ArazzoCriterionError from "./ArazzoCriterionError.mjs";
+class ArazzoCriterionEvaluateError extends ArazzoCriterionError {}
+export default ArazzoCriterionEvaluateError;

package/es/errors/ArazzoCriterionParseError.mjs

@@ -0,0 +1,3 @@
+import ArazzoCriterionError from "./ArazzoCriterionError.mjs";
+class ArazzoCriterionParseError extends ArazzoCriterionError {}
+export default ArazzoCriterionParseError;