@swaggerexpert/arazzo-criterion 1.0.0

package/cjs/errors/ArazzoCriterionError.cjs

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+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);
+    }
+  }
+}
+var _default = exports.default = ArazzoCriterionError;

package/cjs/errors/ArazzoCriterionEvaluateError.cjs

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _ArazzoCriterionError = _interopRequireDefault(require("./ArazzoCriterionError.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class ArazzoCriterionEvaluateError extends _ArazzoCriterionError.default {}
+var _default = exports.default = ArazzoCriterionEvaluateError;

package/cjs/errors/ArazzoCriterionParseError.cjs

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _ArazzoCriterionError = _interopRequireDefault(require("./ArazzoCriterionError.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class ArazzoCriterionParseError extends _ArazzoCriterionError.default {}
+var _default = exports.default = ArazzoCriterionParseError;

package/cjs/evaluate/index.cjs

@@ -0,0 +1,139 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _index = _interopRequireDefault(require("../parse/index.cjs"));
+var _ArazzoCriterionEvaluateError = _interopRequireDefault(require("../errors/ArazzoCriterionEvaluateError.cjs"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/**
+ * Evaluate a "simple" Arazzo criterion condition.
+ *
+ * Runtime expression values are supplied by the caller through `resolve`, which
+ * receives the runtime expression string and its parsed sub-AST, and returns the
+ * concrete value.
+ *
+ * @example
+ * evaluate('$statusCode == 200', {
+ *   resolve: (expression, ast) => (expression === '$statusCode' ? 200 : undefined),
+ * }); // => true
+ */
+const evaluate = (condition, {
+  resolve
+} = {}) => {
+  if (typeof condition !== 'string') {
+    throw new TypeError('Criterion condition must be a string');
+  }
+  if (typeof resolve !== 'function') {
+    throw new TypeError('evaluate requires a "resolve" function in options');
+  }
+  const {
+    result,
+    tree
+  } = (0, _index.default)(condition);
+  if (!result.success) {
+    throw new _ArazzoCriterionEvaluateError.default('Invalid criterion condition', {
+      condition
+    });
+  }
+  return toBoolean(evaluateNode(tree, resolve));
+};
+const evaluateNode = (node, resolve) => {
+  switch (node.type) {
+    case 'LogicalExpression':
+      return evaluateLogical(node, resolve);
+    case 'UnaryExpression':
+      return !toBoolean(evaluateNode(node.argument, resolve));
+    case 'BinaryExpression':
+      return evaluateComparison(node, resolve);
+    case 'Literal':
+      return node.value;
+    case 'RuntimeExpression':
+      return resolve(node.text, node.expression);
+    case 'RuntimeExpressionNavigation':
+      return evaluateNavigation(node, resolve);
+    default:
+      throw new _ArazzoCriterionEvaluateError.default(`Unknown AST node type: ${node.type}`);
+  }
+};
+const evaluateLogical = (node, resolve) => {
+  if (node.operator === '&&') {
+    return toBoolean(evaluateNode(node.left, resolve)) && toBoolean(evaluateNode(node.right, resolve));
+  }
+  // '||'
+  return toBoolean(evaluateNode(node.left, resolve)) || toBoolean(evaluateNode(node.right, resolve));
+};
+const evaluateNavigation = (node, resolve) => {
+  let value = resolve(node.expression.text, node.expression.expression);
+  for (const step of node.navigation) {
+    if (value == null) return undefined;
+    value = step.type === 'MemberAccess' ? value[step.name] : value[step.value];
+  }
+  return value;
+};
+const evaluateComparison = (node, resolve) => {
+  const left = evaluateNode(node.left, resolve);
+  const right = evaluateNode(node.right, resolve);
+  switch (node.operator) {
+    case '==':
+      return looseEquals(left, right);
+    case '!=':
+      return !looseEquals(left, right);
+    case '<':
+    case '<=':
+    case '>':
+    case '>=':
+      return relational(node.operator, left, right);
+    default:
+      throw new _ArazzoCriterionEvaluateError.default(`Unknown comparison operator: ${node.operator}`);
+  }
+};
+
+// null equals only itself; comparing null to any other value is false.
+const looseEquals = (a, b) => {
+  const aNull = a === null || a === undefined;
+  const bNull = b === null || b === undefined;
+  if (aNull || bNull) return aNull && bNull;
+
+  // string comparisons MUST be case insensitive
+  if (typeof a === 'string' && typeof b === 'string') {
+    return a.toLowerCase() === b.toLowerCase();
+  }
+
+  // numeric strings SHOULD be coerced to numbers when compared with a number
+  if (typeof a === 'number' && typeof b === 'string' && isNumeric(b)) return a === Number(b);
+  if (typeof b === 'number' && typeof a === 'string' && isNumeric(a)) return Number(a) === b;
+  return a === b;
+};
+const relational = (operator, a, b) => {
+  // comparing null/undefined with a relational operator is always false
+  if (a === null || a === undefined || b === null || b === undefined) return false;
+  let left = a;
+  let right = b;
+
+  // numeric coercion of numeric strings under numeric operators
+  if (typeof left === 'number' && typeof right === 'string' && isNumeric(right)) right = Number(right);else if (typeof right === 'number' && typeof left === 'string' && isNumeric(left)) left = Number(left);else if (typeof left === 'string' && typeof right === 'string') {
+    // case-insensitive string ordering
+    left = left.toLowerCase();
+    right = right.toLowerCase();
+  }
+  switch (operator) {
+    case '<':
+      return left < right;
+    case '<=':
+      return left <= right;
+    case '>':
+      return left > right;
+    case '>=':
+      return left >= right;
+    default:
+      return false;
+  }
+};
+const isNumeric = str => str.trim() !== '' && Number.isFinite(Number(str));
+
+// A condition passes (truthy) when it evaluates to a truthy value; it fails (falsy)
+// on false, null, or a missing (undefined) value.
+const toBoolean = value => Boolean(value);
+var _default = exports.default = evaluate;