@shko.online/dataverse-odata 0.1.5 → 0.2.0

package/lib/modern/getFilterFromParser.js

@@ -0,0 +1,255 @@
+import { atMostOnce } from './validators/atMostOnce';
+import { hasContent } from './validators/hasContent';
+const option = '$filter';
+const STANDARD_OPERATORS = ['eq', 'ne', 'gt', 'ge', 'lt', 'le'];
+const QUERY_FUNCTION_OPERATORS = ['contains', 'endswith', 'startswith'];
+function isStandardOperator(s) {
+  return STANDARD_OPERATORS.includes(s);
+}
+function isQueryFunctionOperator(s) {
+  return QUERY_FUNCTION_OPERATORS.includes(s);
+}
+const GUID_REGEX = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/;
+function tokenize(input) {
+  const tokens = [];
+  let i = 0;
+  while (i < input.length) {
+    var _input;
+    if (/\s/.test(input[i])) {
+      i++;
+      continue;
+    }
+    if (input[i] === '(') {
+      tokens.push({
+        type: 'lparen',
+        value: '('
+      });
+      i++;
+    } else if (input[i] === ')') {
+      tokens.push({
+        type: 'rparen',
+        value: ')'
+      });
+      i++;
+    } else if (input[i] === ',') {
+      tokens.push({
+        type: 'comma',
+        value: ','
+      });
+      i++;
+    } else if (input[i] === "'") {
+      let j = i + 1;
+      let str = '';
+      while (j < input.length) {
+        if (input[j] === "'" && j + 1 < input.length && input[j + 1] === "'") {
+          str += "'";
+          j += 2;
+        } else if (input[j] === "'") {
+          break;
+        } else {
+          str += input[j];
+          j++;
+        }
+      }
+      tokens.push({
+        type: 'string',
+        value: str
+      });
+      i = j + 1;
+    } else if (/[0-9a-fA-F]/.test(input[i]) && GUID_REGEX.test(input.slice(i))) {
+      tokens.push({
+        type: 'string',
+        value: input.slice(i, i + 36)
+      });
+      i += 36;
+    } else if (/[0-9]/.test(input[i]) || input[i] === '-' && /[0-9]/.test((_input = input[i + 1]) !== null && _input !== void 0 ? _input : '')) {
+      let j = i;
+      if (input[j] === '-') j++;
+      while (j < input.length && /[0-9.]/.test(input[j])) j++;
+      tokens.push({
+        type: 'number',
+        value: input.slice(i, j)
+      });
+      i = j;
+    } else if (/[a-zA-Z_]/.test(input[i])) {
+      let j = i;
+      while (j < input.length && /[a-zA-Z0-9_]/.test(input[j])) j++;
+      tokens.push({
+        type: 'word',
+        value: input.slice(i, j)
+      });
+      i = j;
+    } else {
+      i++;
+    }
+  }
+  return tokens;
+}
+class FilterParser {
+  constructor(tokens) {
+    this.tokens = void 0;
+    this.pos = 0;
+    this.tokens = tokens;
+  }
+  peek() {
+    var _this$tokens$this$pos;
+    return (_this$tokens$this$pos = this.tokens[this.pos]) !== null && _this$tokens$this$pos !== void 0 ? _this$tokens$this$pos : null;
+  }
+  consume(expected) {
+    const token = this.tokens[this.pos++];
+    if (!token) throw new Error(`Unexpected end of filter expression${expected ? `, expected ${expected}` : ''}`);
+    return token;
+  }
+  expect(type, value) {
+    const token = this.consume(`${type}${value ? ` '${value}'` : ''}`);
+    if (token.type !== type || value !== undefined && token.value !== value) {
+      throw new Error(`Expected ${type}${value ? ` '${value}'` : ''} but got ${token.type} '${token.value}'`);
+    }
+    return token;
+  }
+  parse() {
+    const expr = this.parseOr();
+    if (this.pos < this.tokens.length) {
+      throw new Error(`Unexpected token '${this.tokens[this.pos].value}'`);
+    }
+    return expr;
+  }
+  parseOr() {
+    let left = this.parseAnd();
+    while (((_this$peek = this.peek()) === null || _this$peek === void 0 ? void 0 : _this$peek.value) === 'or') {
+      var _this$peek;
+      this.consume();
+      const right = this.parseAnd();
+      left = {
+        operator: 'or',
+        left,
+        right
+      };
+    }
+    return left;
+  }
+  parseAnd() {
+    let left = this.parseNot();
+    while (((_this$peek2 = this.peek()) === null || _this$peek2 === void 0 ? void 0 : _this$peek2.value) === 'and') {
+      var _this$peek2;
+      this.consume();
+      const right = this.parseNot();
+      left = {
+        operator: 'and',
+        left,
+        right
+      };
+    }
+    return left;
+  }
+  parseNot() {
+    var _this$peek3;
+    if (((_this$peek3 = this.peek()) === null || _this$peek3 === void 0 ? void 0 : _this$peek3.value) === 'not') {
+      this.consume();
+      const right = this.parseNot();
+      return {
+        operator: 'not',
+        right
+      };
+    }
+    return this.parsePrimary();
+  }
+  parsePrimary() {
+    const token = this.peek();
+    if (!token) throw new Error('Unexpected end of filter expression');
+    if (token.type === 'lparen') {
+      this.consume();
+      const expr = this.parseOr();
+      this.expect('rparen');
+      return expr;
+    }
+    if (token.type === 'word' && isQueryFunctionOperator(token.value.toLowerCase())) {
+      const func = this.consume().value.toLowerCase();
+      this.expect('lparen');
+      const left = this.expect('word').value;
+      this.expect('comma');
+      const right = this.expect('string').value;
+      this.expect('rparen');
+      return {
+        operator: func,
+        left,
+        right
+      };
+    }
+    if (token.type === 'word') {
+      const left = this.consume().value;
+      const opToken = this.consume(`a comparison operator`);
+      if (!isStandardOperator(opToken.value.toLowerCase())) {
+        throw new Error(`Invalid operator '${opToken.value}'`);
+      }
+      const operator = opToken.value.toLowerCase();
+      const right = this.consume(`a value or column name`);
+      if (right.type === 'string') {
+        return {
+          operator,
+          left,
+          right: right.value
+        };
+      } else if (right.type === 'number') {
+        return {
+          operator,
+          left,
+          right: Number(right.value)
+        };
+      } else if (right.type === 'word') {
+        // Constant keywords stay as StandardOperator; bare identifiers are column comparisons
+        const BOOL_CONSTANTS = ['true', 'false'];
+        if (BOOL_CONSTANTS.includes(right.value.toLowerCase())) {
+          return {
+            operator,
+            left,
+            isBooleanOperation: true,
+            right: right.value === 'true'
+          };
+        } else if (right.value.toLowerCase() === 'null') {
+          return {
+            operator,
+            left,
+            isNullOperation: true,
+            right: null
+          };
+        }
+        return {
+          left,
+          operator,
+          isColumnOperation: true,
+          right: right.value
+        };
+      } else {
+        throw new Error(`Invalid right-hand side value of type '${right.type}' in filter expression`);
+      }
+    }
+    throw new Error(`Unexpected token '${token.value}'`);
+  }
+}
+
+/**
+ * Parses the {@link ODataFilter.$filter $filter} query
+ * @returns {boolean} Returns `false` when the parse has an error
+ */
+export const getFilterFromParser = (parser, result) => {
+  const value = parser.getAll(option);
+  if (value.length === 0) {
+    return true;
+  }
+  if (!atMostOnce(option, value, result) || !hasContent(option, value, result)) {
+    return false;
+  }
+  try {
+    const tokens = tokenize(value[0]);
+    const p = new FilterParser(tokens);
+    result.$filter = p.parse();
+  } catch (e) {
+    result.error = {
+      code: '0x80060888',
+      message: `Syntax error in '$filter': ${e.message}`
+    };
+    return false;
+  }
+  return true;
+};

package/lib/modern/getOrderByFromParser.js

@@ -0,0 +1,72 @@
+import "core-js/modules/esnext.string.match-all.js";
+import { getAliasedProperty } from './getAliasedProperty';
+import { atMostOnce } from './validators/atMostOnce';
+import { hasContent } from './validators/hasContent';
+const option = '$orderby';
+
+/**
+ * Parses the {@link ODataOrderBy.$orderby $orderby} query
+ * @returns Returns `false` when the parse has an error
+ */
+export const getOrderByFromParser = (parser, result) => {
+  let value = parser.getAll(option);
+  if (value.length === 0) {
+    return true;
+  }
+  if (!atMostOnce(option, value, result) || !hasContent(option, value, result)) {
+    return false;
+  }
+  let $orderby = value[0].trimEnd();
+  let $orderbyParts = $orderby.split(',');
+  const orderByArray = [];
+  let position = 0;
+  for (const element of $orderbyParts) {
+    const parts = Array.from(element.matchAll(/\s*(\S+)/gi));
+    if (parts.length > 2) {
+      position = position + parts[0][0].length + parts[1][0].length + parts[2][0].length;
+      result.error = {
+        code: '0x80060888',
+        message: `Syntax error at position ${position} in '${$orderby}'.`
+      };
+      return false;
+    }
+    if (!/^[@a-zA-Z]\w+/gi.test(parts[0][1])) {
+      position = position + parts[0][0].length;
+      result.error = {
+        code: '0x80060888',
+        message: `Syntax error at position ${position} in '${$orderby}'.`
+      };
+      return false;
+    }
+    const orderBy = {
+      column: parts[0][1],
+      asc: true // default is ascending
+    };
+    if (parts[0][1].startsWith('@')) {
+      orderBy.column = getAliasedProperty(parser, result, parts[0][1]);
+      if (!orderBy.column) {
+        return false;
+      }
+    }
+    if (parts.length === 1) {
+      orderByArray.push(orderBy);
+      continue;
+    }
+    if (parts[1][1].toLowerCase() === 'asc') {
+      orderBy.asc = true;
+      orderByArray.push(orderBy);
+    } else if (parts[1][1].toLowerCase() === 'desc') {
+      orderBy.asc = false;
+      orderByArray.push(orderBy);
+    } else {
+      position = position + parts[0][0].length + parts[1][0].length;
+      result.error = {
+        code: '0x80060888',
+        message: `Syntax error at position ${position} in '${$orderby}'.`
+      };
+      return false;
+    }
+  }
+  result.$orderby = orderByArray;
+  return true;
+};

package/lib/modern/getSelectFromParser.js

@@ -0,0 +1,20 @@
+import { atMostOnce } from './validators/atMostOnce';
+const option = '$select';
+
+/**
+ * Parses the {@link ODataSelect.$select $select} query
+ * @returns {boolean} Returns `false` when the parse has an error
+ */
+export const getSelectFromParser = (parser, result) => {
+  const value = parser.getAll(option);
+  if (value.length === 0) {
+    return true;
+  }
+  if (!atMostOnce(option, value, result)) {
+    return false;
+  }
+  if (value.length > 0) {
+    result.$select = value[0].split(',');
+  }
+  return true;
+};

package/lib/modern/getTopFromParser.js

@@ -0,0 +1,33 @@
+import { atMostOnce } from './validators/atMostOnce';
+import { hasContent } from './validators/hasContent';
+const option = '$top';
+
+/**
+ * Parses the {@link ODataTop.$top $top} query
+ * @returns Returns `false` when the parse has an error
+ */
+export const getTopFromParser = (parser, result) => {
+  const value = parser.getAll(option);
+  if (value.length === 0) {
+    return true;
+  }
+  if (!atMostOnce(option, value, result) || !hasContent(option, value, result)) {
+    return false;
+  }
+  let $top;
+  if (!value[0].match(/^\d+$/) || ($top = parseInt(value[0])) < 0) {
+    result.error = {
+      code: '0x0',
+      message: `Invalid value '${value}' for $top query option found. The $top query option requires a non-negative integer value.`
+    };
+    return false;
+  } else if ($top === 0) {
+    result.error = {
+      code: '0x0',
+      message: `Invalid value for $top query option.`
+    };
+    return false;
+  }
+  result.$top = $top;
+  return true;
+};

package/lib/modern/getXQueryFromParser.js

@@ -0,0 +1,19 @@
+import { isGuid } from './validators/isGuid';
+import { recognizedGuid } from './validators/recognizedGuid';
+
+/**
+ * Parses the {@link ODataSavedQuery.savedQuery savedQuery} or
+ * {@link ODataUserQuery.userQuery userQuery} query
+ * @returns Returns `false` when the parse has an error
+ */
+export const getXQueryFromParser = (X, parser, result) => {
+  const value = parser.getAll(X);
+  if (value.length === 0) {
+    return true;
+  }
+  if (!recognizedGuid(value, result) || !isGuid(value, result)) {
+    return false;
+  }
+  result[X] = value[0];
+  return true;
+};

package/lib/modern/index.js

@@ -0,0 +1,9 @@
+export { getExpandFromParser } from './getExpandFromParser';
+export { getFetchXmlFromParser } from './getFetchXmlFromParser';
+export { getOrderByFromParser } from './getOrderByFromParser';
+export { getSelectFromParser } from './getSelectFromParser';
+export { getTopFromParser } from './getTopFromParser';
+export { getXQueryFromParser } from './getXQueryFromParser';
+export { parseOData } from './parseOData';
+import { parseOData } from './parseOData';
+export default parseOData;

package/lib/modern/parseOData.js

@@ -0,0 +1,19 @@
+import { getTopFromParser } from './getTopFromParser';
+import { getSelectFromParser } from './getSelectFromParser';
+import { getExpandFromParser } from './getExpandFromParser';
+import { getFetchXmlFromParser } from './getFetchXmlFromParser';
+import { getXQueryFromParser } from './getXQueryFromParser';
+import { getOrderByFromParser } from './getOrderByFromParser';
+import { getFilterFromParser } from './getFilterFromParser';
+
+/**
+ * parses the OData query and applies some Dataverse validations
+ * @param query The OData query
+ * @returns The parsed OData query
+ */
+export const parseOData = query => {
+  const parser = new URLSearchParams(query);
+  const result = {};
+  getExpandFromParser(parser, result) && getFetchXmlFromParser(parser, result) && getFilterFromParser(parser, result) && getSelectFromParser(parser, result) && getTopFromParser(parser, result) && getXQueryFromParser('savedQuery', parser, result) && getXQueryFromParser('userQuery', parser, result) && getOrderByFromParser(parser, result);
+  return result;
+};

package/lib/modern/validators/atMostOnce.js

@@ -0,0 +1,17 @@
+/**
+ * Options of this type must be specified at most once.
+ * @param option The option being validated (ex. $top)
+ * @param value The result of {@link URLSearchParams.prototype.getAll URLSearchParams.getAll}
+ * @param result The {@link ODataQuery} to append the error to
+ * @returns {boolean} Returns `false` when the parse has an error
+ */
+export const atMostOnce = (option, value, result) => {
+  if (value.length > 1) {
+    result.error = {
+      code: '0x0',
+      message: `Query option '${option}' was specified more than once, but it must be specified at most once.`
+    };
+    return false;
+  }
+  return true;
+};

package/lib/modern/validators/differentFromEmptyString.js

@@ -0,0 +1,16 @@
+/**
+ * 
+ * @param value The result of {@link URLSearchParams.getAll getAll}
+ * @param result The {@link ODataQuery} to append the error to
+ * @returns {boolean} Returns `false` when the parse has an error
+ */
+export const differentFromEmptyString = (value, result) => {
+  if (value[0] === '') {
+    result.error = {
+      code: '0x80040203',
+      message: 'Expected non-empty string.'
+    };
+    return false;
+  }
+  return true;
+};

package/lib/modern/validators/hasContent.js

@@ -0,0 +1,17 @@
+/**
+ * Options of this type must be specified at most once.
+ * @param option The option being validated (ex. $top)
+ * @param value The result of {@link URLSearchParams.getAll getAll}
+ * @param result The {@link ODataQuery} to append the error to
+ * @returns {boolean} Returns `false` when the parse has an error
+ */
+export const hasContent = (query, value, result) => {
+  if (!value[0].trim()) {
+    result.error = {
+      code: '0x0',
+      message: `The value for OData query '${query}' cannot be empty.`
+    };
+    return false;
+  }
+  return true;
+};

package/lib/modern/validators/isGuid.js

@@ -0,0 +1,18 @@
+const guidRegex = /[0-9A-F]{8}\-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}/gi;
+
+/**
+ * 
+ * @param value The result of {@link URLSearchParams.getAll getAll}
+ * @param result The {@link ODataQuery} to append the error to
+ * @returns {boolean} Returns `false` when the parse has an error
+ */
+export const isGuid = (value, result) => {
+  if (!value[0].match(guidRegex)) {
+    result.error = {
+      code: '0x0',
+      message: 'Guid should contain 32 digits with 4 dashes (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx).'
+    };
+    return false;
+  }
+  return true;
+};

package/lib/modern/validators/recognizedGuid.js

@@ -0,0 +1,16 @@
+/**
+ * 
+ * @param value The result of {@link URLSearchParams.getAll getAll}
+ * @param result The {@link ODataQuery} to append the error to
+ * @returns {boolean} Returns `false` when the parse has an error
+ */
+export const recognizedGuid = (value, result) => {
+  if (!value[0].trim()) {
+    result.error = {
+      code: '0x0',
+      message: 'Unrecognized Guid format.'
+    };
+    return false;
+  }
+  return true;
+};