@shko.online/dataverse-odata 0.1.2 → 0.1.4

package/lib/ts3.9/getSelectFromParser.d.ts

@@ -1,7 +1,7 @@
 import type { ODataQuery } from './OData.types';
 /**
  * Parses the {@link ODataSelect.$select $select} query
- * @returns Returns `false` when the parse has an error
+ * @returns {boolean} Returns `false` when the parse has an error
  */
 export declare const getSelectFromParser: (parser: URLSearchParams, result: ODataQuery) => boolean;
 //# sourceMappingURL=getSelectFromParser.d.ts.map

package/lib/ts3.9/getSelectFromParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getSelectFromParser.d.ts","sourceRoot":"","sources":["../../src/getSelectFromParser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAe,MAAM,eAAe,CAAC;AAE7D;;;GAGG;AACH,eAAO,MAAM,mBAAmB,WAAY,eAAe,UAAU,UAAU,KAAG,OAMjF,CAAC"}
+{"version":3,"file":"getSelectFromParser.d.ts","sourceRoot":"","sources":["../../src/getSelectFromParser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAe,MAAM,eAAe,CAAC;AAK7D;;;GAGG;AACH,eAAO,MAAM,mBAAmB,WAAY,eAAe,UAAU,UAAU,KAAG,OAYjF,CAAC"}

package/lib/ts3.9/getTopFromParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getTopFromParser.d.ts","sourceRoot":"","sources":["../../src/getTopFromParser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAY,MAAM,eAAe,CAAC;AAG1D;;;GAGG;AACH,eAAO,MAAM,gBAAgB,WAAY,eAAe,UAAU,UAAU,KAAG,OAuB9E,CAAC"}
+{"version":3,"file":"getTopFromParser.d.ts","sourceRoot":"","sources":["../../src/getTopFromParser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAY,MAAM,eAAe,CAAC;AAM1D;;;GAGG;AACH,eAAO,MAAM,gBAAgB,WAAY,eAAe,UAAU,UAAU,KAAG,OAwB9E,CAAC"}

package/lib/ts3.9/getXQueryFromParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getXQueryFromParser.d.ts","sourceRoot":"","sources":["../../src/getXQueryFromParser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAmC,MAAM,eAAe,CAAC;AAIjF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,MACzB,YAAY,GAAG,WAAW,UACrB,eAAe,UACf,UAAU,KACnB,OAoBF,CAAC"}
+{"version":3,"file":"getXQueryFromParser.d.ts","sourceRoot":"","sources":["../../src/getXQueryFromParser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAmC,MAAM,eAAe,CAAC;AAIjF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,MACzB,YAAY,GAAG,WAAW,UACrB,eAAe,UACf,UAAU,KACnB,OAWF,CAAC"}

package/lib/ts3.9/parseOData.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parseOData.d.ts","sourceRoot":"","sources":["../../src/parseOData.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAQhD;;;;GAIG;AACH,eAAO,MAAM,UAAU,UAAW,MAAM,eAsBvC,CAAC"}
+{"version":3,"file":"parseOData.d.ts","sourceRoot":"","sources":["../../src/parseOData.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAShD;;;;GAIG;AACH,eAAO,MAAM,UAAU,UAAW,MAAM,eAavC,CAAC"}

package/lib/ts3.9/validators/atMostOnce.d.ts

@@ -0,0 +1,10 @@
+import type { ODataQuery } from '../OData.types';
+/**
+ * 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 declare const atMostOnce: (option: string, value: string[], result: ODataQuery) => boolean;
+//# sourceMappingURL=atMostOnce.d.ts.map

package/lib/ts3.9/validators/atMostOnce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atMostOnce.d.ts","sourceRoot":"","sources":["../../../src/validators/atMostOnce.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,WAAY,MAAM,SAAS,MAAM,EAAE,UAAU,UAAU,YAS7E,CAAC"}

package/lib/ts3.9/validators/differentFromEmptyString.d.ts

@@ -0,0 +1,9 @@
+import type { ODataQuery } from '../OData.types';
+/**
+ *
+ * @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 declare const differentFromEmptyString: (value: string[], result: ODataQuery) => boolean;
+//# sourceMappingURL=differentFromEmptyString.d.ts.map

package/lib/ts3.9/validators/differentFromEmptyString.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"differentFromEmptyString.d.ts","sourceRoot":"","sources":["../../../src/validators/differentFromEmptyString.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,UAAW,MAAM,EAAE,UAAU,UAAU,YAS3E,CAAC"}

package/lib/ts3.9/validators/hasContent.d.ts

@@ -0,0 +1,10 @@
+import type { ODataQuery } from '../OData.types';
+/**
+ * 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 declare const hasContent: (query: string, value: string[], result: ODataQuery) => boolean;
+//# sourceMappingURL=hasContent.d.ts.map

package/lib/ts3.9/validators/hasContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasContent.d.ts","sourceRoot":"","sources":["../../../src/validators/hasContent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,UAAW,MAAM,SAAS,MAAM,EAAE,UAAU,UAAU,YAS5E,CAAC"}

package/lib/ts3.9/validators/isGuid.d.ts

@@ -0,0 +1,9 @@
+import type { ODataQuery } from '../OData.types';
+/**
+ *
+ * @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 declare const isGuid: (value: string[], result: ODataQuery) => boolean;
+//# sourceMappingURL=isGuid.d.ts.map

package/lib/ts3.9/validators/isGuid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isGuid.d.ts","sourceRoot":"","sources":["../../../src/validators/isGuid.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAIjD;;;;;GAKG;AACH,eAAO,MAAM,MAAM,UAAW,MAAM,EAAE,UAAU,UAAU,YASzD,CAAC"}

package/lib/ts3.9/validators/recognizedGuid.d.ts

@@ -0,0 +1,9 @@
+import type { ODataQuery } from '../OData.types';
+/**
+ *
+ * @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 declare const recognizedGuid: (value: string[], result: ODataQuery) => boolean;
+//# sourceMappingURL=recognizedGuid.d.ts.map

package/lib/ts3.9/validators/recognizedGuid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recognizedGuid.d.ts","sourceRoot":"","sources":["../../../src/validators/recognizedGuid.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD;;;;;GAKG;AACH,eAAO,MAAM,cAAc,UAAW,MAAM,EAAE,UAAU,UAAU,YASjE,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shko.online/dataverse-odata",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "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 && node ../scripts/build.js",

package/src/OData.types.d.ts

@@ -1,11 +1,11 @@
-export interface ODataError {
+interface ODataError {
     error?: {
         code: string;
         message: string;
     };
 }
 
-export interface ODataExpand {
+interface ODataExpand {
     /**
      * Use the {@link ODataExpand.$expand $expand} system query option in the navigation properties
      * to control what data from related entities is returned.
@@ -26,9 +26,9 @@ export interface ODataExpand {
     };
 }
 
-export type ODataExpandQuery = ODataSelect & ODataExpand;
+type ODataExpandQuery = ODataSelect & ODataExpand;
 
-export interface ODataFilter {
+interface ODataFilter {
     /**
      * Use the {@link ODataFilter.$filter $filter} system query option to set criteria for which rows will be returned.
      *
@@ -37,7 +37,7 @@ export interface ODataFilter {
     $filter?: StandardOperator;
 }
 
-export interface ODataFetch {
+interface ODataFetch {
     /**
      * You can compose a FetchXML query for a specific table.
      * Then, URL-encode the XML and pass it to the entity set
@@ -48,7 +48,7 @@ export interface ODataFetch {
     fetchXml?: XMLDocument;
 }
 
-export interface ODataOrderBy {
+interface ODataOrderBy {
     /**
      * Specify the order in which items are returned using the {@link ODataOrderBy.$orderby $orderby}
      * system query option. Use the asc or desc suffix to specify ascending or descending order
@@ -59,7 +59,7 @@ export interface ODataOrderBy {
     $orderby?: { column: string; asc: boolean }[];
 }
 
-export interface ODataSavedQuery {
+interface ODataSavedQuery {
     /**
      * You can use the `savedqueryid` value and pass it as the value to the {@link ODataSavedQuery.savedQuery savedQuery}
      * parameter to the entity set that matches the corresponding `returnedtypecode` of the saved query.
@@ -69,7 +69,7 @@ export interface ODataSavedQuery {
     savedQuery?: string;
 }
 
-export interface ODataSelect {
+interface ODataSelect {
     /**
      * Use the {@link ODataSelect.$select $select} system query option to limit the properties returned.
      *
@@ -81,7 +81,7 @@ export interface ODataSelect {
     $select?: string[];
 }
 
-export interface ODataTop {
+interface ODataTop {
     /**
      * You can limit the number of results returned by using the {@link ODataTop.$top $top} system query option.
      *
@@ -90,7 +90,7 @@ export interface ODataTop {
     $top?: number;
 }
 
-export interface ODataUserQuery {
+interface ODataUserQuery {
     /**
      * You can use the `userqueryid` value and pass it as the value to the {@link OdataUserQuery.userQuery userQuery}
      * parameter to the entity set that matches the corresponding `returnedtypecode` of the user query.
@@ -100,9 +100,9 @@ export interface ODataUserQuery {
     userQuery?: string;
 }
 
-export type StandardOperators = 'eq' | 'ne' | 'gt' | 'ge' | 'lt' | 'le';
+type StandardOperators = 'eq' | 'ne' | 'gt' | 'ge' | 'lt' | 'le';
 
-export interface StandardOperator {
+interface StandardOperator {
     operator: StandardOperators;
     /**
      * The left side of the 'X' operator must be a property of the entity.
@@ -114,18 +114,18 @@ export interface StandardOperator {
     right: string | number;
 }
 
-export interface UnaryOperator {
+interface UnaryOperator {
     operator: 'not';
     right: StandardOperator;
 }
 
-export interface BinaryOperator {
+interface BinaryOperator {
     operator: 'and' | 'or';
     left: StandardOperator;
     right: StandardOperator;
 }
 
-export type ODataQuery = ODataError &
+type ODataQuery = ODataError &
     ODataExpand &
     ODataFetch &
     ODataFilter &
@@ -134,3 +134,21 @@ export type ODataQuery = ODataError &
     ODataSelect &
     ODataTop &
     ODataUserQuery;
+
+export type {
+    BinaryOperator,
+    ODataError,
+    ODataExpand,
+    ODataExpandQuery,
+    ODataFetch,
+    ODataFilter,
+    ODataOrderBy,
+    ODataQuery,
+    ODataSavedQuery,
+    ODataSelect,
+    ODataTop,
+    ODataUserQuery,
+    StandardOperator,
+    StandardOperators,
+    UnaryOperator,    
+};

package/src/getExpandFromParser.ts

@@ -1,25 +1,33 @@
 import type { ODataError, ODataExpand, ODataExpandQuery, ODataQuery } from './OData.types';
 
 import { getSelectFromParser } from './getSelectFromParser';
+import { atMostOnce } from './validators/atMostOnce';
+
+const option = '$expand';
 
 /**
  * Parses the {@link ODataExpand.$expand $expand} query
  * @returns Returns `false` when the parse has an error
  */
 export const getExpandFromParser = (parser: URLSearchParams, result: ODataQuery): boolean => {
-    const $expand = parser.get('$expand');
-    if ($expand !== null) {
-        result.$expand = {};
+    const value = parser.getAll(option);
+    if (value.length === 0) {
+        return true;
+    }
+    if (!atMostOnce(option, value, result)) {
+        return false;
+    }
 
-        if (!extractExpand($expand, result)) {
-            return false;
-        }
+    result.$expand = {};
+    if (!extractExpand(value[0], result)) {
+        return false;
     }
+
     return true;
 };
 
 const extractExpand = (value: string, $expand: ODataExpand & ODataError) => {
-    const match = value.match(/^\s*(\w(\w|\d|_)*)\s*(,|\()?\s*/);
+    const match = value.match(/^\s*(\w(\w|\d|_)*)\s*(,|\(|\))?\s*/);
     if (
         match === null ||
         (match[0].length < value.length && match[3] === null) ||
@@ -27,7 +35,7 @@ const extractExpand = (value: string, $expand: ODataExpand & ODataError) => {
     ) {
         $expand.error = {
             code: '0x0',
-            message: 'invalid expand expression',
+            message: `Term '${value}' is not valid in a $select or $expand expression.`,
         };
         return false;
     }
@@ -59,7 +67,10 @@ const extractExpand = (value: string, $expand: ODataExpand & ODataError) => {
                 return false;
             }
             if (innerExpand.$expand === undefined && innerExpand.$select === undefined) {
-                $expand.error = { code: '0x0', message: 'Empty expand' };
+                $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;
@@ -90,7 +101,7 @@ const getClosingBracket = (value: string): { index: number; error?: string } =>
     while (depth > 0) {
         const match = value.substring(startAt).match(/\(|\)/);
         if (match === null) {
-            return { error: 'no closing bracket found', index: -1 };
+            return { error: 'Found an unbalanced bracket expression.', index: -1 };
         }
         if (match[0] === ')') {
             depth -= 1;
@@ -100,7 +111,7 @@ const getClosingBracket = (value: string): { index: number; error?: string } =>
         } else {
             depth += 1;
         }
-        startAt = (match.index || 0) + 1;
+        startAt += (match.index || 0) + 1;
     }
-    return { error: 'no closing bracket found', index: -1 };
+    return { error: 'Found an unbalanced bracket expression.', index: -1 };
 };

package/src/getFetchXmlFromParser.ts

@@ -1,56 +1,59 @@
 import type { ODataQuery, ODataFetch } from './OData.types';
+import { atMostOnce } from './validators/atMostOnce';
+import { differentFromEmptyString } from './validators/differentFromEmptyString';
+
+const option = 'fetchXml';
 
 /**
  * Parses the {@link ODataFetch.fetchXml fetchXml} query
  * @returns Returns `false` when the parse has an error
  */
 export const getFetchXmlFromParser = (parser: URLSearchParams, result: ODataQuery): boolean => {
-    const fetchXml = parser.get('fetchXml');
-    if (fetchXml !== null) {
-        if (fetchXml === '') {
-            result.error = {
-                code: '0x80040203',
-                message: 'Expected non-empty string.',
-            };
-            return false;
-        }
+    const value = parser.getAll(option);
+    if (value.length === 0) {
+        return true;
+    }
+    if (!atMostOnce(option, value, result) || !differentFromEmptyString(value, result)) {
+        return false;
+    }
 
-        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() as Element;
-        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() as Element;
-        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;
+    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() as Element;
+    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() as Element;
+    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;
 };

package/src/getOrderByFromParser.ts

@@ -1,6 +1,8 @@
 import type { ODataQuery, ODataOrderBy } from './OData.types';
-import { validateNotEmpty } from './validateNotEmpty';
+import { atMostOnce } from './validators/atMostOnce';
+import { hasContent } from './validators/hasContent';
 
+const option = '$orderby';
 const edmProperty = /\w{1-255}/gi;
 
 /**
@@ -8,35 +10,37 @@ const edmProperty = /\w{1-255}/gi;
  * @returns Returns `false` when the parse has an error
  */
 export const getOrderByFromParser = (parser: URLSearchParams, result: ODataQuery): boolean => {
-    let $orderby = parser.get('$orderby');
-    if ($orderby !== null) {
-        if (!validateNotEmpty('$orderby', $orderby, 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();
+    const orderByArray: ODataOrderBy['$orderby'] = [];
+    for (let i = 0; i < $orderby.length; i++) {
+        if (false /* syntax error */) {
+            result.error = {
+                code: '0x0',
+                message: `Syntax error at position ${i} in '${$orderby}'.`,
+            };
+
             return false;
         }
-        $orderby = $orderby.trimEnd();
-        const orderByArray: ODataOrderBy['$orderby'] = [];
-        for (let i = 0; i < $orderby.length; i++) {
-            if (false /* syntax error */) {
-                result.error = {
-                    code: '0x0',
-                    message: `Syntax error at position ${i} in '${$orderby}'.`,
-                };
-    
-                return false;
-            }
+    }
+
+    orderByArray.forEach((orderBy) => {
+        if (!orderBy.column?.match(edmProperty)) {
+            result.error = {
+                code: '0x80060888',
+                message: 'Order By Property must be of type EdmProperty',
+            };
+            return false;
         }
+    });
 
-        orderByArray.forEach((orderBy) => {
-            if (!orderBy.column?.match(edmProperty)) {
-                result.error = {
-                    code: '0x80060888',
-                    message: 'Order By Property must be of type EdmProperty',
-                };
-                return false;
-            }
-        });
+    result.$orderby = orderByArray;
 
-        result.$orderby = orderByArray;
-    }
     return true;
 };

package/src/getSelectFromParser.ts

@@ -1,13 +1,22 @@
 import type { ODataQuery, ODataSelect } from './OData.types';
+import { atMostOnce } from './validators/atMostOnce';
+
+const option = '$select';
 
 /**
  * Parses the {@link ODataSelect.$select $select} query
- * @returns Returns `false` when the parse has an error
+ * @returns {boolean} Returns `false` when the parse has an error
  */
 export const getSelectFromParser = (parser: URLSearchParams, result: ODataQuery): boolean => {
-    const $select = parser.get('$select');
-    if ($select !== null) {
-        result.$select = $select.split(',');
+    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/src/getTopFromParser.ts

@@ -1,31 +1,35 @@
 import type { ODataQuery, ODataTop } from './OData.types';
-import { validateNotEmpty } from './validateNotEmpty';
+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: URLSearchParams, result: ODataQuery): boolean => {
-    const $topValue = parser.get('$top');
-    if ($topValue !== null) {
-        if (!validateNotEmpty('$orderby', $topValue, result)) {
-            return false;
-        }
-        let $top: number;
-        if (!$topValue.match(/^\d+$/) || ($top = parseInt($topValue)) < 0) {
-            result.error = {
-                code: '0x0',
-                message: `Invalid value '${$topValue}' 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;
+    const value = parser.getAll(option);
+    if (value.length === 0) {
+        return true;
+    }
+    if (!atMostOnce(option, value, result) || !hasContent(option, value, result)) {
+        return false;
+    }
+    let $top: number;
+    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/src/getXQueryFromParser.ts

@@ -1,6 +1,6 @@
 import type { ODataQuery, ODataSavedQuery, ODataUserQuery } from './OData.types';
-
-const guidRegex = /[0-9A-F]{8}\-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}/gi;
+import { isGuid } from './validators/isGuid';
+import { recognizedGuid } from './validators/recognizedGuid';
 
 /**
  * Parses the {@link ODataSavedQuery.savedQuery savedQuery} or
@@ -12,23 +12,14 @@ export const getXQueryFromParser = (
     parser: URLSearchParams,
     result: ODataQuery,
 ): boolean => {
-    const xQuery = parser.get(X);
-    if (xQuery !== null) {
-        if (!xQuery.trim()) {
-            result.error = {
-                code: '0x0',
-                message: 'Unrecognized Guid format.',
-            };
-            return false;
-        }
-        if (!xQuery.match(guidRegex)) {
-            result.error = {
-                code: '0x0',
-                message: 'Guid should contain 32 digits with 4 dashes (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx).',
-            };
-            return false;
-        }
-        result[X] = xQuery;
+    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;
 };