@shko.online/dataverse-odata 0.1.0 → 0.1.2

package/src/getExpandFromParser.ts

@@ -1,105 +1,106 @@
-import type { ODataError, ODataExpand, ODataExpandQuery, ODataQuery } from './OData.types';
-import { getSelectFromParser } from './getSelectFromParser';
-
-/**
- * Parses the $expand query
- * @returns Returns true when the parse has an error
- */
-export const getExpandFromParser = (parser: URLSearchParams, result: ODataQuery): boolean => {
-    const $expand = parser.get('$expand');
-    if ($expand !== null) {
-        result.$expand = {};
-
-        if (extractExpand($expand, result)) {
-            return true;
-        }
-    }
-    return false;
-};
-
-const extractExpand = (value: string, $expand: ODataExpand & ODataError) => {
-    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: 'invalid expand expression',
-        };
-        return true;
-    }
-    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 true;
-        }
-
-        if ($expand.$expand !== undefined) {
-            const innerExpand = {} as ODataExpandQuery & ODataError;
-            const parser = new URLSearchParams('?' + value.substring(matchLength, matchLength + index));
-            if (getSelectFromParser(parser, innerExpand)) {
-                $expand.error = innerExpand.error;
-                return true;
-            }
-            if (getExpandFromParser(parser, innerExpand)) {
-                $expand.error = innerExpand.error;
-                return true;
-            }
-            if (innerExpand.$expand === undefined && innerExpand.$select === undefined) {
-                $expand.error = { code: '0x0', message: 'Empty expand' };
-                return true;
-            }
-            $expand.$expand[match[1]] = innerExpand;
-        }
-
-        matchLength = matchLength + index;
-        const secondMatch = value.substring(matchLength + 1).match(/\s*(,?)\s*d/);
-        if (secondMatch !== null) {
-            matchLength = matchLength + secondMatch[0].length;
-            if (secondMatch[1] !== null) {
-                matchSeparator = ',';
-            }
-        }
-    }
-
-    if (matchSeparator === ',') {
-        if (extractExpand(value.substring(matchLength), $expand)) {
-            return true;
-        }
-    }
-
-    return false;
-};
-
-const getClosingBracket = (value: string): { index: number; error?: string } => {
-    let depth = 1;
-    let startAt = 0;
-    while (depth > 0) {
-        const match = value.substring(startAt).match(/\(|\)/);
-        if (match === null) {
-            return { error: 'no closing bracket found', 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: 'no closing bracket found', index: -1 };
-};
+import type { ODataError, ODataExpand, ODataExpandQuery, ODataQuery } from './OData.types';
+
+import { getSelectFromParser } from './getSelectFromParser';
+
+/**
+ * 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 = {};
+
+        if (!extractExpand($expand, result)) {
+            return false;
+        }
+    }
+    return true;
+};
+
+const extractExpand = (value: string, $expand: ODataExpand & ODataError) => {
+    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: 'invalid 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 = {} as ODataExpandQuery & ODataError;
+            const parser = new URLSearchParams('?' + value.substring(matchLength, matchLength + index));
+            if (!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: 'Empty expand' };
+                return false;
+            }
+            $expand.$expand[match[1]] = innerExpand;
+        }
+
+        matchLength = matchLength + index;
+        const secondMatch = value.substring(matchLength + 1).match(/\s*(,?)\s*d/);
+        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: string): { index: number; error?: string } => {
+    let depth = 1;
+    let startAt = 0;
+    while (depth > 0) {
+        const match = value.substring(startAt).match(/\(|\)/);
+        if (match === null) {
+            return { error: 'no closing bracket found', 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: 'no closing bracket found', index: -1 };
+};

package/src/getFetchXmlFromParser.ts

@@ -1,48 +1,56 @@
-import type { ODataQuery } from './OData.types';
-
-/**
- * Parses the $fetchXml query
- * @returns Returns true when the parse has an error
- */
-export const getFetchXmlFromParser = (parser: URLSearchParams, result: ODataQuery): boolean => {
-    const fetchXml = parser.get('fetchXml');
-    if (fetchXml !== null) {
-        const serializer = new DOMParser();
-        const fetchXmlDocument = serializer.parseFromString(fetchXml, 'text/xml');
-        if (fetchXmlDocument.documentElement.tagName === 'parsererror') {
-            result.error = {
-                code: '0x80040201',
-                message: 'Invalid XML.',
-            };
-            return true;
-        }
-        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 true;
-        }
-        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 true;
-        }
-        result.fetchXml = fetchXmlDocument;
-    }
-    return false;
-};
+import type { ODataQuery, ODataFetch } from './OData.types';
+
+/**
+ * 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 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

@@ -0,0 +1,42 @@
+import type { ODataQuery, ODataOrderBy } from './OData.types';
+import { validateNotEmpty } from './validateNotEmpty';
+
+const edmProperty = /\w{1-255}/gi;
+
+/**
+ * Parses the {@link ODataOrderBy.$orderby $orderby} query
+ * @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)) {
+            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;
+            }
+        });
+
+        result.$orderby = orderByArray;
+    }
+    return true;
+};

package/src/getSelectFromParser.ts

@@ -1,13 +1,13 @@
-import type { ODataQuery } from './OData.types';
-
-/**
- * Parses the $select query
- * @returns Returns true 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(',');
-    }
-    return false;
-};
+import type { ODataQuery, ODataSelect } from './OData.types';
+
+/**
+ * Parses the {@link ODataSelect.$select $select} query
+ * @returns 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(',');
+    }
+    return true;
+};

package/src/getTopFromParser.ts

@@ -1,27 +1,31 @@
-import type { ODataQuery } from './OData.types';
-
-/**
- * Parses the $top query
- * @returns Returns true when the parse has an error
- */
-export const getTopFromParser = (parser: URLSearchParams, result: ODataQuery): boolean => {
-    const $topValue = parser.get('$top');
-    if ($topValue !== null) {
-        let $top;
-        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 true;
-        } else if ($top === 0) {
-            result.error = {
-                code: '0x0',
-                message: `Invalid value for $top query option.`,
-            };
-            return true;
-        }
-        result.$top = $top;
-    }
-    return false;
-};
+import type { ODataQuery, ODataTop } from './OData.types';
+import { validateNotEmpty } from './validateNotEmpty';
+
+/**
+ * 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;
+    }
+    return true;
+};

package/src/getXQueryFromParser.ts

@@ -0,0 +1,34 @@
+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;
+
+/**
+ * Parses the {@link ODataSavedQuery.savedQuery savedQuery} or
+ * {@link ODataUserQuery.userQuery userQuery} query
+ * @returns Returns `false` when the parse has an error
+ */
+export const getXQueryFromParser = (
+    X: 'savedQuery' | 'userQuery',
+    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;
+    }
+    return true;
+};

package/src/index.ts

@@ -1,16 +1,24 @@
-export type {
-    BinaryOperator,
-    ODataError,
-    ODataExpand,
-    ODataExpandQuery,
-    ODataFetch,
-    ODataFilter,
-    ODataQuery,
-    ODataSelect,
-    ODataTop,
-    StandardOperator,
-    StandardOperators,
-} from './OData.types';
-export { parseOData } from './parseOData';
-import { parseOData } from './parseOData';
-export default parseOData;
+export type {
+    BinaryOperator,
+    ODataError,
+    ODataExpand,
+    ODataExpandQuery,
+    ODataFetch,
+    ODataFilter,
+    ODataQuery,
+    ODataSelect,
+    ODataTop,
+    StandardOperator,
+    StandardOperators,
+} from './OData.types';
+
+export { getExpandFromParser } from './getExpandFromParser';
+export { getFetchXmlFromParser } from './getFetchXmlFromParser';
+export { getOrderByFromParser } from './getOrderByFromParser';
+export { getSelectFromParser } from './getSelectFromParser';
+export { getTopFromParser } from './getTopFromParser';
+export { getXQueryFromParser } from './getXQueryFromParser';
+
+export { parseOData } from './parseOData';
+import { parseOData } from './parseOData';
+export default parseOData;

package/src/parseOData.ts

@@ -1,23 +1,36 @@
-import type { ODataQuery } from './OData.types';
-import { getTopFromParser } from './getTopFromParser';
-import { getSelectFromParser } from './getSelectFromParser';
-import { getExpandFromParser } from './getExpandFromParser';
-import { getFetchXmlFromParser } from './getFetchXmlFromParser';
-
-export const parseOData = (query: string) => {
-    const parser = new URLSearchParams(query);
-    const result = {} as ODataQuery;
-    if (getExpandFromParser(parser, result)) {
-        return result;
-    }
-    if (getSelectFromParser(parser, result)) {
-        return result;
-    }
-    if (getTopFromParser(parser, result)) {
-        return result;
-    }
-    if (getFetchXmlFromParser(parser, result)) {
-        return result;
-    }
-    return result;
-};
+import type { ODataQuery } from './OData.types';
+
+import { getTopFromParser } from './getTopFromParser';
+import { getSelectFromParser } from './getSelectFromParser';
+import { getExpandFromParser } from './getExpandFromParser';
+import { getFetchXmlFromParser } from './getFetchXmlFromParser';
+import { getXQueryFromParser } from './getXQueryFromParser';
+
+/**
+ * parses the OData query and applies some Dataverse validations
+ * @param query The OData query
+ * @returns The parsed OData query
+ */
+export const parseOData = (query: string) => {
+    const parser = new URLSearchParams(query);
+    const result = {} as ODataQuery;
+    if (!getExpandFromParser(parser, result)) {
+        return result;
+    }
+    if (!getSelectFromParser(parser, result)) {
+        return result;
+    }
+    if (!getTopFromParser(parser, result)) {
+        return result;
+    }
+    if (!getFetchXmlFromParser(parser, result)) {
+        return result;
+    }
+    if (!getXQueryFromParser('savedQuery', parser, result)) {
+        return result;
+    }
+    if (!getXQueryFromParser('userQuery', parser, result)) {
+        return result;
+    }
+    return result;
+};

package/src/validateNotEmpty.ts

@@ -0,0 +1,12 @@
+import type { ODataQuery } from './OData.types';
+
+export const validateNotEmpty = (query: string, value: string, result: ODataQuery) => {
+    if (!value.trim()) {
+        result.error = {
+            code: '0x0',
+            message: `The value for OData query '${query}' cannot be empty.`,
+        };
+        return false;
+    }
+    return true;
+};

package/tsconfig.build.json

@@ -1,9 +1,9 @@
-{
-    "extends": "./tsconfig.json",
-    "exclude": [
-        "tests",
-        "lib",
-        "node_modules",
-        "jest.config.ts"
-    ]
+{
+    "extends": "./tsconfig.json",
+    "exclude": [
+        "tests",
+        "lib",
+        "node_modules",
+        "jest.config.ts"
+    ]
 }