@shko.online/dataverse-odata 0.1.6 → 0.2.1

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "js/ts.tsdk.path": "node_modules\\typescript\\lib"
+}

package/CHANGELOG.md

@@ -1,3 +1,23 @@
+## [0.2.1](https://github.com/Shko-Online/dataverse-odata/compare/v0.2.0...v0.2.1) (2026-05-13)
+
+
+### Bug Fixes
+
+* Fixed exports for index ([d623a40](https://github.com/Shko-Online/dataverse-odata/commit/d623a40515dec7888997634cbf5d043ebbf91461))
+
+# [0.2.0](https://github.com/Shko-Online/dataverse-odata/compare/v0.1.6...v0.2.0) (2026-04-11)
+
+
+### Bug Fixes
+
+* column comparison uses no keyword prefix, e.g. firstname eq lastname ([34727d5](https://github.com/Shko-Online/dataverse-odata/commit/34727d5ce8698b4d0ec822ee226637169c881028))
+* distinguish between null, boolean and column operators ([62511ef](https://github.com/Shko-Online/dataverse-odata/commit/62511ef624ebbd06aa6a7732b9693e7f50dbbbce))
+
+
+### Features
+
+* implement $filter parser and add sample tests for each operator ([e2f5387](https://github.com/Shko-Online/dataverse-odata/commit/e2f538740422ba51c13ff13ecb9222606a19ce17))
+
 ## [0.1.6](https://github.com/Shko-Online/dataverse-odata/compare/v0.1.5...v0.1.6) (2026-03-15)
 
 

package/azure-pipelines.yml

@@ -2,9 +2,9 @@ pool:
   vmImage: ubuntu-latest
 
 steps:
-- task: NodeTool@0
+- task: UseNode@1
   inputs:
-    versionSpec: '24.x'
+    version: '24.x'
   displayName: 'Install Node.js'
 
 - task: Npm@1

package/lib/cjs/getFetchXmlFromParser.js

@@ -31,7 +31,7 @@ const getFetchXmlFromParser = (parser, result) => {
     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')) {
+  if (fetchXmlDocument.documentElement.children.length != 1 || !entity?.getAttribute('name')) {
     result.error = {
       code: '0x80041102',
       message: 'Entity Name was not specified in FetchXml String.'

package/lib/cjs/getFilterFromParser.js

@@ -5,7 +5,231 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getFilterFromParser = void 0;
 var _atMostOnce = require("./validators/atMostOnce");
+var _hasContent = require("./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) {
+    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 (/\d/.test(input[i]) || input[i] === '-' && /\d/.test(input[i + 1] ?? '')) {
+      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 && /\w/.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() {
+    return this.tokens[this.pos] ?? null;
+  }
+  consume(expected) {
+    const token = this.tokens[this.pos++];
+    const expectedString = expected ? `, expected ${expected}` : '';
+    if (!token) throw new Error(`Unexpected end of filter expression${expectedString}`);
+    return token;
+  }
+  expect(type, value) {
+    const valueString = value ? ` '${value}'` : '';
+    const token = this.consume(`${type}${valueString}`);
+    if (token.type !== type || value !== undefined && token.value !== value) {
+      throw new Error(`Expected ${type}${valueString} 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()?.value === 'or') {
+      this.consume();
+      const right = this.parseAnd();
+      left = {
+        operator: 'or',
+        left,
+        right
+      };
+    }
+    return left;
+  }
+  parseAnd() {
+    let left = this.parseNot();
+    while (this.peek()?.value === 'and') {
+      this.consume();
+      const right = this.parseNot();
+      left = {
+        operator: 'and',
+        left,
+        right
+      };
+    }
+    return left;
+  }
+  parseNot() {
+    if (this.peek()?.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
@@ -16,15 +240,19 @@ const getFilterFromParser = (parser, result) => {
   if (value.length === 0) {
     return true;
   }
-  if (!(0, _atMostOnce.atMostOnce)(option, value, result)) {
+  if (!(0, _atMostOnce.atMostOnce)(option, value, result) || !(0, _hasContent.hasContent)(option, value, result)) {
     return false;
   }
-  if (value.length > 0) {
-    result.$filter = {
-      operator: 'eq',
-      left: '',
-      right: ''
+  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/cjs/index.js

@@ -3,7 +3,18 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+Object.defineProperty(exports, "default", {
+  enumerable: true,
+  get: function () {
+    return _parseOData.parseOData;
+  }
+});
+Object.defineProperty(exports, "getAliasedProperty", {
+  enumerable: true,
+  get: function () {
+    return _getAliasedProperty.getAliasedProperty;
+  }
+});
 Object.defineProperty(exports, "getExpandFromParser", {
   enumerable: true,
   get: function () {
@@ -16,6 +27,12 @@ Object.defineProperty(exports, "getFetchXmlFromParser", {
     return _getFetchXmlFromParser.getFetchXmlFromParser;
   }
 });
+Object.defineProperty(exports, "getFilterFromParser", {
+  enumerable: true,
+  get: function () {
+    return _getFilterFromParser.getFilterFromParser;
+  }
+});
 Object.defineProperty(exports, "getOrderByFromParser", {
   enumerable: true,
   get: function () {
@@ -46,11 +63,12 @@ Object.defineProperty(exports, "parseOData", {
     return _parseOData.parseOData;
   }
 });
+var _getAliasedProperty = require("./getAliasedProperty");
 var _getExpandFromParser = require("./getExpandFromParser");
 var _getFetchXmlFromParser = require("./getFetchXmlFromParser");
+var _getFilterFromParser = require("./getFilterFromParser");
 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;
+var _parseOData = require("./parseOData");

package/lib/esm/getFetchXmlFromParser.js

@@ -25,7 +25,7 @@ export const getFetchXmlFromParser = (parser, result) => {
     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')) {
+  if (fetchXmlDocument.documentElement.children.length != 1 || !entity?.getAttribute('name')) {
     result.error = {
       code: '0x80041102',
       message: 'Entity Name was not specified in FetchXml String.'

package/lib/esm/getFilterFromParser.js

@@ -1,5 +1,229 @@
 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) {
+    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 (/\d/.test(input[i]) || input[i] === '-' && /\d/.test(input[i + 1] ?? '')) {
+      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 && /\w/.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() {
+    return this.tokens[this.pos] ?? null;
+  }
+  consume(expected) {
+    const token = this.tokens[this.pos++];
+    const expectedString = expected ? `, expected ${expected}` : '';
+    if (!token) throw new Error(`Unexpected end of filter expression${expectedString}`);
+    return token;
+  }
+  expect(type, value) {
+    const valueString = value ? ` '${value}'` : '';
+    const token = this.consume(`${type}${valueString}`);
+    if (token.type !== type || value !== undefined && token.value !== value) {
+      throw new Error(`Expected ${type}${valueString} 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()?.value === 'or') {
+      this.consume();
+      const right = this.parseAnd();
+      left = {
+        operator: 'or',
+        left,
+        right
+      };
+    }
+    return left;
+  }
+  parseAnd() {
+    let left = this.parseNot();
+    while (this.peek()?.value === 'and') {
+      this.consume();
+      const right = this.parseNot();
+      left = {
+        operator: 'and',
+        left,
+        right
+      };
+    }
+    return left;
+  }
+  parseNot() {
+    if (this.peek()?.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
@@ -10,15 +234,19 @@ export const getFilterFromParser = (parser, result) => {
   if (value.length === 0) {
     return true;
   }
-  if (!atMostOnce(option, value, result)) {
+  if (!atMostOnce(option, value, result) || !hasContent(option, value, result)) {
     return false;
   }
-  if (value.length > 0) {
-    result.$filter = {
-      operator: 'eq',
-      left: '',
-      right: ''
+  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/esm/index.js

@@ -1,9 +1,9 @@
+export { getAliasedProperty } from './getAliasedProperty';
 export { getExpandFromParser } from './getExpandFromParser';
 export { getFetchXmlFromParser } from './getFetchXmlFromParser';
+export { getFilterFromParser } from './getFilterFromParser';
 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;
+export { parseOData, parseOData as default } from './parseOData';

package/lib/modern/getFetchXmlFromParser.js

@@ -25,7 +25,7 @@ export const getFetchXmlFromParser = (parser, result) => {
     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')) {
+  if (fetchXmlDocument.documentElement.children.length != 1 || !(entity !== null && entity !== void 0 && entity.getAttribute('name'))) {
     result.error = {
       code: '0x80041102',
       message: 'Entity Name was not specified in FetchXml String.'