@shko.online/dataverse-odata 0.1.5 → 0.1.6

package/.github/workflows/publish.yml

@@ -29,12 +29,12 @@ jobs:
         with:
           node-version: "lts/*"
 
-      - name: Update npm
-        run: npm install -g npm@latest
-
       - name: Install dependencies
         run: npm ci
 
+      - name: Build
+        run: npm run build
+
       - name: Run tests
         run: npm test
 

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.1.6](https://github.com/Shko-Online/dataverse-odata/compare/v0.1.5...v0.1.6) (2026-03-15)
+
+
+### Bug Fixes
+
+* build before publish ([abf325d](https://github.com/Shko-Online/dataverse-odata/commit/abf325da1f8f7ee2d1ba44f35f0b182de9d9cb6a))
+
 ## [0.1.5](https://github.com/Shko-Online/dataverse-odata/compare/v0.1.4...v0.1.5) (2026-03-15)
 
 

package/lib/cjs/OData.types.d.js

@@ -0,0 +1 @@
+"use strict";

package/lib/cjs/getAliasedProperty.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAliasedProperty = void 0;
+/**
+ * Recursively gets the value of an aliased property. For example, if the query is `$orderby=@p1` and `@p1=name`, this function will return `name`
+ * @param parser The URLSearchParams object containing the query parameters
+ * @param result Will contain the error details in case there is any
+ * @param property The property to expand
+ * @returns The expanded property or null when there is an error
+ */
+const getAliasedProperty = (parser, result, property) => {
+  let propertyName = parser.get(property);
+  if (!propertyName) {
+    result.error = {
+      code: '0x80060888',
+      message: 'Order By Property must be of type EdmProperty'
+    };
+    return null;
+  }
+  if (!/^[@a-zA-Z]\w+/gi.test(propertyName)) {
+    const position = propertyName.length;
+    result.error = {
+      code: '0x80060888',
+      message: `Syntax error at position ${position} in '${propertyName}'.`
+    };
+    return null;
+  }
+  if (propertyName.startsWith('@')) {
+    return getAliasedProperty(parser, result, propertyName);
+  }
+  return propertyName;
+};
+exports.getAliasedProperty = getAliasedProperty;

package/lib/cjs/getExpandFromParser.js

@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getExpandFromParser = void 0;
+var _getSelectFromParser = require("./getSelectFromParser");
+var _atMostOnce = require("./validators/atMostOnce");
+const option = '$expand';
+
+/**
+ * Parses the {@link ODataExpand.$expand $expand} query
+ * @returns Returns `false` when the parse has an error
+ */
+const getExpandFromParser = (parser, result) => {
+  const value = parser.getAll(option);
+  if (value.length === 0) {
+    return true;
+  }
+  if (!(0, _atMostOnce.atMostOnce)(option, value, result)) {
+    return false;
+  }
+  result.$expand = {};
+  if (!extractExpand(value[0], result)) {
+    return false;
+  }
+  return true;
+};
+exports.getExpandFromParser = getExpandFromParser;
+const extractExpand = (value, $expand) => {
+  const match = value.match(/^\s*(\w(\w|\d|_)*)\s*(,|\(|\))?\s*/);
+  if (match === null || match[0].length < value.length && match[3] === null || match[0].length === value.length && match[3] !== undefined) {
+    $expand.error = {
+      code: '0x0',
+      message: `Term '${value}' is not valid in a $select or $expand expression.`
+    };
+    return false;
+  }
+  let matchSeparator = match[3];
+  let matchLength = match[0].length;
+  if (matchSeparator !== '(') {
+    if ($expand.$expand !== undefined) {
+      $expand.$expand[match[1]] = {
+        $select: []
+      };
+    }
+  } else {
+    const {
+      index,
+      error
+    } = getClosingBracket(value.substring(matchLength));
+    if (error) {
+      $expand.error = {
+        code: '0x0',
+        message: error
+      };
+      return false;
+    }
+    if ($expand.$expand !== undefined) {
+      const innerExpand = {};
+      const parser = new URLSearchParams('?' + value.substring(matchLength, matchLength + index));
+      if (!(0, _getSelectFromParser.getSelectFromParser)(parser, innerExpand)) {
+        $expand.error = innerExpand.error;
+        return false;
+      }
+      if (!getExpandFromParser(parser, innerExpand)) {
+        $expand.error = innerExpand.error;
+        return false;
+      }
+      if (innerExpand.$expand === undefined && innerExpand.$select === undefined) {
+        $expand.error = {
+          code: '0x0',
+          message: `Missing expand option on navigation property '${match[1]}'. If a parenthesis expression follows an expanded navigation property, then at least one expand option must be provided.`
+        };
+        return false;
+      }
+      $expand.$expand[match[1]] = innerExpand;
+    }
+    matchLength = matchLength + index;
+    const secondMatch = new RegExp(/\s*(,?)\s*d/).exec(value.substring(matchLength + 1));
+    if (secondMatch !== null) {
+      matchLength = matchLength + secondMatch[0].length;
+      if (secondMatch[1] !== null) {
+        matchSeparator = ',';
+      }
+    }
+  }
+  if (matchSeparator === ',') {
+    if (!extractExpand(value.substring(matchLength), $expand)) {
+      return false;
+    }
+  }
+  return true;
+};
+const getClosingBracket = value => {
+  let depth = 1;
+  let startAt = 0;
+  while (depth > 0) {
+    const match = value.substring(startAt).match(/\(|\)/);
+    if (match === null) {
+      return {
+        error: 'Found an unbalanced bracket expression.',
+        index: -1
+      };
+    }
+    if (match[0] === ')') {
+      depth -= 1;
+      if (depth === 0) {
+        return {
+          index: match.index || 0
+        };
+      }
+    } else {
+      depth += 1;
+    }
+    startAt += (match.index || 0) + 1;
+  }
+  return {
+    error: 'Found an unbalanced bracket expression.',
+    index: -1
+  };
+};

package/lib/cjs/getFetchXmlFromParser.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getFetchXmlFromParser = void 0;
+var _atMostOnce = require("./validators/atMostOnce");
+var _differentFromEmptyString = require("./validators/differentFromEmptyString");
+const option = 'fetchXml';
+
+/**
+ * Parses the {@link ODataFetch.fetchXml fetchXml} query
+ * @returns Returns `false` when the parse has an error
+ */
+const getFetchXmlFromParser = (parser, result) => {
+  const value = parser.getAll(option);
+  if (value.length === 0) {
+    return true;
+  }
+  if (!(0, _atMostOnce.atMostOnce)(option, value, result) || !(0, _differentFromEmptyString.differentFromEmptyString)(value, result)) {
+    return false;
+  }
+  const fetchXml = value[0];
+  const serializer = new DOMParser();
+  const fetchXmlDocument = serializer.parseFromString(fetchXml, 'text/xml');
+  if (fetchXmlDocument.documentElement.tagName === 'parsererror') {
+    result.error = {
+      code: '0x80040201',
+      message: 'Invalid XML.'
+    };
+    return false;
+  }
+  const entity = fetchXmlDocument.evaluate('fetch/entity', fetchXmlDocument, null, XPathResult.ANY_TYPE, null).iterateNext();
+  if (fetchXmlDocument.documentElement.children.length != 1 || !entity || !entity.getAttribute('name')) {
+    result.error = {
+      code: '0x80041102',
+      message: 'Entity Name was not specified in FetchXml String.'
+    };
+    return false;
+  }
+  const invalidAttribute = fetchXmlDocument.evaluate('fetch/entity/*[not(self::filter or self::order or self::link-entity or self::attribute or self::all-attributes or self::no-attrs)]', fetchXmlDocument, null, XPathResult.ANY_TYPE, null).iterateNext();
+  if (invalidAttribute) {
+    result.error = {
+      code: '0x8004111c',
+      message: `Invalid Child Node, valid nodes are filter, order, link-entity, attribute, all-attributes, no-attrs. NodeName = ${invalidAttribute.tagName} NodeXml = ${invalidAttribute.outerHTML}`
+    };
+    return false;
+  }
+  result.fetchXml = fetchXmlDocument;
+  return true;
+};
+exports.getFetchXmlFromParser = getFetchXmlFromParser;

package/lib/cjs/getFilterFromParser.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getFilterFromParser = void 0;
+var _atMostOnce = require("./validators/atMostOnce");
+const option = '$filter';
+
+/**
+ * Parses the {@link ODataFilter.$filter $filter} query
+ * @returns {boolean} Returns `false` when the parse has an error
+ */
+const getFilterFromParser = (parser, result) => {
+  const value = parser.getAll(option);
+  if (value.length === 0) {
+    return true;
+  }
+  if (!(0, _atMostOnce.atMostOnce)(option, value, result)) {
+    return false;
+  }
+  if (value.length > 0) {
+    result.$filter = {
+      operator: 'eq',
+      left: '',
+      right: ''
+    };
+  }
+  return true;
+};
+exports.getFilterFromParser = getFilterFromParser;

package/lib/cjs/getOrderByFromParser.js

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getOrderByFromParser = void 0;
+var _getAliasedProperty = require("./getAliasedProperty");
+var _atMostOnce = require("./validators/atMostOnce");
+var _hasContent = require("./validators/hasContent");
+const option = '$orderby';
+
+/**
+ * Parses the {@link ODataOrderBy.$orderby $orderby} query
+ * @returns Returns `false` when the parse has an error
+ */
+const getOrderByFromParser = (parser, result) => {
+  let value = parser.getAll(option);
+  if (value.length === 0) {
+    return true;
+  }
+  if (!(0, _atMostOnce.atMostOnce)(option, value, result) || !(0, _hasContent.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 = (0, _getAliasedProperty.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;
+};
+exports.getOrderByFromParser = getOrderByFromParser;

package/lib/cjs/getSelectFromParser.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSelectFromParser = void 0;
+var _atMostOnce = require("./validators/atMostOnce");
+const option = '$select';
+
+/**
+ * Parses the {@link ODataSelect.$select $select} query
+ * @returns {boolean} Returns `false` when the parse has an error
+ */
+const getSelectFromParser = (parser, result) => {
+  const value = parser.getAll(option);
+  if (value.length === 0) {
+    return true;
+  }
+  if (!(0, _atMostOnce.atMostOnce)(option, value, result)) {
+    return false;
+  }
+  if (value.length > 0) {
+    result.$select = value[0].split(',');
+  }
+  return true;
+};
+exports.getSelectFromParser = getSelectFromParser;

package/lib/cjs/getTopFromParser.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTopFromParser = void 0;
+var _atMostOnce = require("./validators/atMostOnce");
+var _hasContent = require("./validators/hasContent");
+const option = '$top';
+
+/**
+ * Parses the {@link ODataTop.$top $top} query
+ * @returns Returns `false` when the parse has an error
+ */
+const getTopFromParser = (parser, result) => {
+  const value = parser.getAll(option);
+  if (value.length === 0) {
+    return true;
+  }
+  if (!(0, _atMostOnce.atMostOnce)(option, value, result) || !(0, _hasContent.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;
+};
+exports.getTopFromParser = getTopFromParser;

package/lib/cjs/getXQueryFromParser.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getXQueryFromParser = void 0;
+var _isGuid = require("./validators/isGuid");
+var _recognizedGuid = require("./validators/recognizedGuid");
+/**
+ * Parses the {@link ODataSavedQuery.savedQuery savedQuery} or
+ * {@link ODataUserQuery.userQuery userQuery} query
+ * @returns Returns `false` when the parse has an error
+ */
+const getXQueryFromParser = (X, parser, result) => {
+  const value = parser.getAll(X);
+  if (value.length === 0) {
+    return true;
+  }
+  if (!(0, _recognizedGuid.recognizedGuid)(value, result) || !(0, _isGuid.isGuid)(value, result)) {
+    return false;
+  }
+  result[X] = value[0];
+  return true;
+};
+exports.getXQueryFromParser = getXQueryFromParser;

package/lib/cjs/index.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+Object.defineProperty(exports, "getExpandFromParser", {
+  enumerable: true,
+  get: function () {
+    return _getExpandFromParser.getExpandFromParser;
+  }
+});
+Object.defineProperty(exports, "getFetchXmlFromParser", {
+  enumerable: true,
+  get: function () {
+    return _getFetchXmlFromParser.getFetchXmlFromParser;
+  }
+});
+Object.defineProperty(exports, "getOrderByFromParser", {
+  enumerable: true,
+  get: function () {
+    return _getOrderByFromParser.getOrderByFromParser;
+  }
+});
+Object.defineProperty(exports, "getSelectFromParser", {
+  enumerable: true,
+  get: function () {
+    return _getSelectFromParser.getSelectFromParser;
+  }
+});
+Object.defineProperty(exports, "getTopFromParser", {
+  enumerable: true,
+  get: function () {
+    return _getTopFromParser.getTopFromParser;
+  }
+});
+Object.defineProperty(exports, "getXQueryFromParser", {
+  enumerable: true,
+  get: function () {
+    return _getXQueryFromParser.getXQueryFromParser;
+  }
+});
+Object.defineProperty(exports, "parseOData", {
+  enumerable: true,
+  get: function () {
+    return _parseOData.parseOData;
+  }
+});
+var _getExpandFromParser = require("./getExpandFromParser");
+var _getFetchXmlFromParser = require("./getFetchXmlFromParser");
+var _getOrderByFromParser = require("./getOrderByFromParser");
+var _getSelectFromParser = require("./getSelectFromParser");
+var _getTopFromParser = require("./getTopFromParser");
+var _getXQueryFromParser = require("./getXQueryFromParser");
+var _parseOData = require("./parseOData");
+var _default = exports.default = _parseOData.parseOData;

package/lib/cjs/parseOData.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseOData = void 0;
+var _getTopFromParser = require("./getTopFromParser");
+var _getSelectFromParser = require("./getSelectFromParser");
+var _getExpandFromParser = require("./getExpandFromParser");
+var _getFetchXmlFromParser = require("./getFetchXmlFromParser");
+var _getXQueryFromParser = require("./getXQueryFromParser");
+var _getOrderByFromParser = require("./getOrderByFromParser");
+var _getFilterFromParser = require("./getFilterFromParser");
+/**
+ * parses the OData query and applies some Dataverse validations
+ * @param query The OData query
+ * @returns The parsed OData query
+ */
+const parseOData = query => {
+  const parser = new URLSearchParams(query);
+  const result = {};
+  (0, _getExpandFromParser.getExpandFromParser)(parser, result) && (0, _getFetchXmlFromParser.getFetchXmlFromParser)(parser, result) && (0, _getFilterFromParser.getFilterFromParser)(parser, result) && (0, _getSelectFromParser.getSelectFromParser)(parser, result) && (0, _getTopFromParser.getTopFromParser)(parser, result) && (0, _getXQueryFromParser.getXQueryFromParser)('savedQuery', parser, result) && (0, _getXQueryFromParser.getXQueryFromParser)('userQuery', parser, result) && (0, _getOrderByFromParser.getOrderByFromParser)(parser, result);
+  return result;
+};
+exports.parseOData = parseOData;

package/lib/cjs/validators/atMostOnce.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.atMostOnce = void 0;
+/**
+ * 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
+ */
+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;
+};
+exports.atMostOnce = atMostOnce;

package/lib/cjs/validators/differentFromEmptyString.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.differentFromEmptyString = void 0;
+/**
+ * 
+ * @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
+ */
+const differentFromEmptyString = (value, result) => {
+  if (value[0] === '') {
+    result.error = {
+      code: '0x80040203',
+      message: 'Expected non-empty string.'
+    };
+    return false;
+  }
+  return true;
+};
+exports.differentFromEmptyString = differentFromEmptyString;

package/lib/cjs/validators/hasContent.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hasContent = void 0;
+/**
+ * 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
+ */
+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;
+};
+exports.hasContent = hasContent;

package/lib/cjs/validators/isGuid.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isGuid = void 0;
+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
+ */
+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;
+};
+exports.isGuid = isGuid;

package/lib/cjs/validators/recognizedGuid.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.recognizedGuid = void 0;
+/**
+ * 
+ * @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
+ */
+const recognizedGuid = (value, result) => {
+  if (!value[0].trim()) {
+    result.error = {
+      code: '0x0',
+      message: 'Unrecognized Guid format.'
+    };
+    return false;
+  }
+  return true;
+};
+exports.recognizedGuid = recognizedGuid;