@shko.online/dataverse-odata 0.1.6 → 0.2.0

package/CHANGELOG.md

@@ -1,3 +1,16 @@
+# [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,7 +2,7 @@ pool:
   vmImage: ubuntu-latest
 
 steps:
-- task: NodeTool@0
+- task: NodeTool@1
   inputs:
     versionSpec: '24.x'
   displayName: 'Install Node.js'

package/lib/cjs/getFilterFromParser.js

@@ -5,7 +5,229 @@ 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 (/[0-9]/.test(input[i]) || input[i] === '-' && /[0-9]/.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 && /[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() {
+    return 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()?.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 +238,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/esm/getFilterFromParser.js

@@ -1,5 +1,227 @@
 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 (/[0-9]/.test(input[i]) || input[i] === '-' && /[0-9]/.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 && /[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() {
+    return 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()?.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 +232,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/modern/getFilterFromParser.js

@@ -1,5 +1,232 @@
 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
@@ -10,15 +237,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/ts3.4/OData.types.d.ts

@@ -33,7 +33,7 @@ interface ODataFilter {
      */
     $filter?: FilterOperator;
 }
-type FilterOperator = StandardOperator | ColumnOperator | UnaryOperator | BinaryOperator | QueryFunctionOperator;
+type FilterOperator = StandardOperator | BooleanColumnOperator | NullOperator | ColumnOperator | UnaryOperator | BinaryOperator | QueryFunctionOperator;
 interface ODataFetch {
     /**
      * You can compose a FetchXML query for a specific table.
@@ -101,9 +101,40 @@ type StandardOperators = StandardEqualityOperators | 'gt' | 'ge' | 'lt' | 'le';
  * * Microsoft Docs: {@link https://learn.microsoft.com/en-us/power-apps/developer/data-platform/webapi/query/filter-rows#column-comparison Column comparison }
  */
 interface ColumnOperator {
-    column: string;
+    /**
+     * The left side of the 'X' operator must be a property of the entity.
+     */
+    left: string;
     operator: StandardOperators;
-    otherColumn: string;
+    isColumnOperation: true;
+    /**
+     * The right side of the 'X' operator must be a property of the entity.
+     */
+    right: string;
+}
+interface BooleanColumnOperator {
+    /**
+     * The left side of the 'X' operator must be a property of the entity.
+     */
+    left: string;
+    operator: StandardOperators;
+    isBooleanOperation: true;
+    /**
+     * The right side of the 'X' operator must be a property of the entity.
+     */
+    right: boolean;
+}
+interface NullOperator {
+    /**
+     * The left side of the 'X' operator must be a property of the entity.
+     */
+    left: string;
+    operator: StandardOperators;
+    isNullOperation: true;
+    /**
+     * The right side of the 'X' operator must be null.
+     */
+    right: null;
 }
 interface StandardOperator {
     operator: StandardOperators;
@@ -138,4 +169,4 @@ interface BinaryOperator {
     right: FilterOperator;
 }
 type ODataQuery = ODataError & ODataExpand & ODataFetch & ODataFilter & ODataOrderBy & ODataSavedQuery & ODataSelect & ODataTop & ODataUserQuery;
-export { BinaryOperator, ODataError, ODataExpand, ODataExpandQuery, ODataFetch, ODataFilter, ODataOrderBy, ODataQuery, ODataSavedQuery, ODataSelect, ODataTop, ODataUserQuery, StandardOperator, StandardOperators, UnaryOperator, };
+export { BinaryOperator, ColumnOperator, FilterOperator, ODataError, ODataExpand, ODataExpandQuery, ODataFetch, ODataFilter, ODataOrderBy, ODataQuery, ODataSavedQuery, ODataSelect, ODataTop, ODataUserQuery, QueryFunctionOperator, QueryFunctionOperators, StandardOperator, StandardOperators, UnaryOperator, };

package/lib/ts3.9/OData.types.d.ts

@@ -33,7 +33,7 @@ interface ODataFilter {
      */
     $filter?: FilterOperator;
 }
-type FilterOperator = StandardOperator | ColumnOperator | UnaryOperator | BinaryOperator | QueryFunctionOperator;
+type FilterOperator = StandardOperator | BooleanColumnOperator | NullOperator | ColumnOperator | UnaryOperator | BinaryOperator | QueryFunctionOperator;
 interface ODataFetch {
     /**
      * You can compose a FetchXML query for a specific table.
@@ -101,9 +101,40 @@ type StandardOperators = StandardEqualityOperators | 'gt' | 'ge' | 'lt' | 'le';
  * * Microsoft Docs: {@link https://learn.microsoft.com/en-us/power-apps/developer/data-platform/webapi/query/filter-rows#column-comparison Column comparison }
  */
 interface ColumnOperator {
-    column: string;
+    /**
+     * The left side of the 'X' operator must be a property of the entity.
+     */
+    left: string;
     operator: StandardOperators;
-    otherColumn: string;
+    isColumnOperation: true;
+    /**
+     * The right side of the 'X' operator must be a property of the entity.
+     */
+    right: string;
+}
+interface BooleanColumnOperator {
+    /**
+     * The left side of the 'X' operator must be a property of the entity.
+     */
+    left: string;
+    operator: StandardOperators;
+    isBooleanOperation: true;
+    /**
+     * The right side of the 'X' operator must be a property of the entity.
+     */
+    right: boolean;
+}
+interface NullOperator {
+    /**
+     * The left side of the 'X' operator must be a property of the entity.
+     */
+    left: string;
+    operator: StandardOperators;
+    isNullOperation: true;
+    /**
+     * The right side of the 'X' operator must be null.
+     */
+    right: null;
 }
 interface StandardOperator {
     operator: StandardOperators;
@@ -138,4 +169,4 @@ interface BinaryOperator {
     right: FilterOperator;
 }
 type ODataQuery = ODataError & ODataExpand & ODataFetch & ODataFilter & ODataOrderBy & ODataSavedQuery & ODataSelect & ODataTop & ODataUserQuery;
-export type { BinaryOperator, ODataError, ODataExpand, ODataExpandQuery, ODataFetch, ODataFilter, ODataOrderBy, ODataQuery, ODataSavedQuery, ODataSelect, ODataTop, ODataUserQuery, StandardOperator, StandardOperators, UnaryOperator, };
+export type { BinaryOperator, ColumnOperator, FilterOperator, ODataError, ODataExpand, ODataExpandQuery, ODataFetch, ODataFilter, ODataOrderBy, ODataQuery, ODataSavedQuery, ODataSelect, ODataTop, ODataUserQuery, QueryFunctionOperator, QueryFunctionOperators, StandardOperator, StandardOperators, UnaryOperator, };

package/lib/ts4.2/OData.types.d.ts

@@ -37,7 +37,14 @@ interface ODataFilter {
     $filter?: FilterOperator;
 }
 
-type FilterOperator = StandardOperator | ColumnOperator | UnaryOperator | BinaryOperator | QueryFunctionOperator; 
+type FilterOperator =
+    | StandardOperator
+    | BooleanColumnOperator
+    | NullOperator
+    | ColumnOperator
+    | UnaryOperator
+    | BinaryOperator
+    | QueryFunctionOperator;
 
 interface ODataFetch {
     /**
@@ -107,15 +114,47 @@ type StandardEqualityOperators = 'eq' | 'ne';
 type StandardOperators = StandardEqualityOperators | 'gt' | 'ge' | 'lt' | 'le';
 
 /**
- * 
+ *
  * * Microsoft Docs: {@link https://learn.microsoft.com/en-us/power-apps/developer/data-platform/webapi/query/filter-rows#column-comparison Column comparison }
  */
 interface ColumnOperator {
-    column: string;
+    /**
+     * The left side of the 'X' operator must be a property of the entity.
+     */
+    left: string;
+    operator: StandardOperators;
+    isColumnOperation: true;
+    /**
+     * The right side of the 'X' operator must be a property of the entity.
+     */
+    right: string;
+}
+
+interface BooleanColumnOperator {
+    /**
+     * The left side of the 'X' operator must be a property of the entity.
+     */
+    left: string;
     operator: StandardOperators;
-    otherColumn: string;
+    isBooleanOperation: true;
+    /**
+     * The right side of the 'X' operator must be a property of the entity.
+     */
+    right: boolean;
 }
 
+interface NullOperator {
+    /**
+     * The left side of the 'X' operator must be a property of the entity.
+     */
+    left: string;
+    operator: StandardOperators;
+    isNullOperation: true;
+    /**
+     * The right side of the 'X' operator must be null.
+     */
+    right: null;
+}
 
 interface StandardOperator {
     operator: StandardOperators;
@@ -166,6 +205,8 @@ type ODataQuery = ODataError &
 
 export type {
     BinaryOperator,
+    ColumnOperator,
+    FilterOperator,
     ODataError,
     ODataExpand,
     ODataExpandQuery,
@@ -177,7 +218,9 @@ export type {
     ODataSelect,
     ODataTop,
     ODataUserQuery,
+    QueryFunctionOperator,
+    QueryFunctionOperators,
     StandardOperator,
     StandardOperators,
-    UnaryOperator,    
+    UnaryOperator,
 };

package/lib/ts4.2/getFilterFromParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getFilterFromParser.d.ts","sourceRoot":"","sources":["../../src/getFilterFromParser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAe,MAAM,eAAe,CAAC;AAK7D;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAAI,QAAQ,eAAe,EAAE,QAAQ,UAAU,KAAG,OAajF,CAAC"}
+{"version":3,"file":"getFilterFromParser.d.ts","sourceRoot":"","sources":["../../src/getFilterFromParser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAkB,MAAM,eAAe,CAAC;AAuMhE;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAAI,QAAQ,eAAe,EAAE,QAAQ,UAAU,KAAG,OAoBjF,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shko.online/dataverse-odata",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "description": "This package will help parse OData strings (only the Microsoft Dataverse subset). It can be used as a validator, or you can build some javascript library which consumes the output of this library.",
   "scripts": {
     "build": "npm run lint && build-npm-package",

package/src/OData.types.d.ts

@@ -37,7 +37,14 @@ interface ODataFilter {
     $filter?: FilterOperator;
 }
 
-type FilterOperator = StandardOperator | ColumnOperator | UnaryOperator | BinaryOperator | QueryFunctionOperator; 
+type FilterOperator =
+    | StandardOperator
+    | BooleanColumnOperator
+    | NullOperator
+    | ColumnOperator
+    | UnaryOperator
+    | BinaryOperator
+    | QueryFunctionOperator;
 
 interface ODataFetch {
     /**
@@ -107,15 +114,47 @@ type StandardEqualityOperators = 'eq' | 'ne';
 type StandardOperators = StandardEqualityOperators | 'gt' | 'ge' | 'lt' | 'le';
 
 /**
- * 
+ *
  * * Microsoft Docs: {@link https://learn.microsoft.com/en-us/power-apps/developer/data-platform/webapi/query/filter-rows#column-comparison Column comparison }
  */
 interface ColumnOperator {
-    column: string;
+    /**
+     * The left side of the 'X' operator must be a property of the entity.
+     */
+    left: string;
+    operator: StandardOperators;
+    isColumnOperation: true;
+    /**
+     * The right side of the 'X' operator must be a property of the entity.
+     */
+    right: string;
+}
+
+interface BooleanColumnOperator {
+    /**
+     * The left side of the 'X' operator must be a property of the entity.
+     */
+    left: string;
     operator: StandardOperators;
-    otherColumn: string;
+    isBooleanOperation: true;
+    /**
+     * The right side of the 'X' operator must be a property of the entity.
+     */
+    right: boolean;
 }
 
+interface NullOperator {
+    /**
+     * The left side of the 'X' operator must be a property of the entity.
+     */
+    left: string;
+    operator: StandardOperators;
+    isNullOperation: true;
+    /**
+     * The right side of the 'X' operator must be null.
+     */
+    right: null;
+}
 
 interface StandardOperator {
     operator: StandardOperators;
@@ -166,6 +205,8 @@ type ODataQuery = ODataError &
 
 export type {
     BinaryOperator,
+    ColumnOperator,
+    FilterOperator,
     ODataError,
     ODataExpand,
     ODataExpandQuery,
@@ -177,7 +218,9 @@ export type {
     ODataSelect,
     ODataTop,
     ODataUserQuery,
+    QueryFunctionOperator,
+    QueryFunctionOperators,
     StandardOperator,
     StandardOperators,
-    UnaryOperator,    
+    UnaryOperator,
 };

package/src/getFilterFromParser.ts

@@ -1,8 +1,202 @@
-import type { ODataQuery, ODataFilter } from './OData.types';
+import type { ODataQuery, FilterOperator } from './OData.types';
 import { atMostOnce } from './validators/atMostOnce';
+import { hasContent } from './validators/hasContent';
 
 const option = '$filter';
 
+const STANDARD_OPERATORS = ['eq', 'ne', 'gt', 'ge', 'lt', 'le'] as const;
+const QUERY_FUNCTION_OPERATORS = ['contains', 'endswith', 'startswith'] as const;
+
+type StandardOp = (typeof STANDARD_OPERATORS)[number];
+type QueryFunctionOp = (typeof QUERY_FUNCTION_OPERATORS)[number];
+
+function isStandardOperator(s: string): s is StandardOp {
+    return (STANDARD_OPERATORS as readonly string[]).includes(s);
+}
+
+function isQueryFunctionOperator(s: string): s is QueryFunctionOp {
+    return (QUERY_FUNCTION_OPERATORS as readonly string[]).includes(s);
+}
+
+type TokenType = 'lparen' | 'rparen' | 'comma' | 'word' | 'string' | 'number';
+
+interface Token {
+    type: TokenType;
+    value: string;
+}
+
+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: string): Token[] {
+    const tokens: Token[] = [];
+    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 (/[0-9]/.test(input[i]) || (input[i] === '-' && /[0-9]/.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 && /[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 {
+    private tokens: Token[];
+    private pos = 0;
+
+    constructor(tokens: Token[]) {
+        this.tokens = tokens;
+    }
+
+    private peek(): Token | null {
+        return this.tokens[this.pos] ?? null;
+    }
+
+    private consume(expected?: string): Token {
+        const token = this.tokens[this.pos++];
+        if (!token) throw new Error(`Unexpected end of filter expression${expected ? `, expected ${expected}` : ''}`);
+        return token;
+    }
+
+    private expect(type: TokenType, value?: string): Token {
+        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(): FilterOperator {
+        const expr = this.parseOr();
+        if (this.pos < this.tokens.length) {
+            throw new Error(`Unexpected token '${this.tokens[this.pos].value}'`);
+        }
+        return expr;
+    }
+
+    private parseOr(): FilterOperator {
+        let left = this.parseAnd();
+        while (this.peek()?.value === 'or') {
+            this.consume();
+            const right = this.parseAnd();
+            left = { operator: 'or', left, right };
+        }
+        return left;
+    }
+
+    private parseAnd(): FilterOperator {
+        let left = this.parseNot();
+        while (this.peek()?.value === 'and') {
+            this.consume();
+            const right = this.parseNot();
+            left = { operator: 'and', left, right };
+        }
+        return left;
+    }
+
+    private parseNot(): FilterOperator {
+        if (this.peek()?.value === 'not') {
+            this.consume();
+            const right = this.parseNot();
+            return { operator: 'not', right };
+        }
+        return this.parsePrimary();
+    }
+
+    private parsePrimary(): FilterOperator {
+        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() as QueryFunctionOp;
+            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() as StandardOp;
+            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
@@ -12,12 +206,19 @@ export const getFilterFromParser = (parser: URLSearchParams, result: ODataQuery)
     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 as Error).message}`,
+        };
+        return false;
     }
     return true;
 };