@salesforce/lds-network-nimbus 1.124.2 → 1.124.4

package/dist/main.js

@@ -7,776 +7,776 @@
 import { idleDetector } from 'o11y/client';
 import { HttpStatusCode } from '@luvio/engine';
 
-const { keys, create, assign, entries } = Object;
-const { stringify, parse } = JSON;
-const { push, join, slice } = Array.prototype;
+const { keys, create, assign, entries } = Object;
+const { stringify, parse } = JSON;
+const { push, join, slice } = Array.prototype;
 const { isArray, from } = Array;
 
-function ldsParamsToString(params) {
-    const returnParams = create(null);
-    const keys$1 = keys(params);
-    for (let i = 0, len = keys$1.length; i < len; i++) {
-        const key = keys$1[i];
-        const value = params[key];
-        if (value === undefined) {
-            // filter out params that have no value
-            continue;
-        }
-        if (isArray(value)) {
-            // filter out empty arrays
-            if (value.length > 0) {
-                returnParams[key] = value.join(',');
-            }
-        }
-        else {
-            returnParams[key] = `${value}`;
-        }
-        if (isObject(value) === true && keys(value).length > 0) {
-            returnParams[key] = stringify(value);
-        }
-    }
-    return returnParams;
-}
-function statusTextFromStatusCode(status) {
-    switch (status) {
-        case HttpStatusCode.Ok:
-            return 'OK';
-        case HttpStatusCode.NotModified:
-            return 'Not Modified';
-        case HttpStatusCode.NotFound:
-            return 'Not Found';
-        case HttpStatusCode.BadRequest:
-            return 'Bad Request';
-        case HttpStatusCode.ServerError:
-            return 'Server Error';
-        default:
-            return `Unexpected HTTP Status Code: ${status}`;
-    }
-}
-function methodFromResourceRequestMethod(method) {
-    switch (method.toLowerCase()) {
-        case 'get':
-            return 'GET';
-        case 'put':
-            return 'PUT';
-        case 'post':
-            return 'POST';
-        case 'delete':
-            return 'DELETE';
-        case 'patch':
-            return 'PATCH';
-        default:
-            throw Error(`Unexpected method ${method}`);
-    }
-}
-function priorityFromResourceRequest(request) {
-    switch (request.priority) {
-        case 'background':
-            return 'background';
-        case 'high':
-            return 'high';
-        case 'normal':
-        default:
-            return 'normal';
-    }
-}
-function isStatusOk(status) {
-    return status >= 200 && status <= 299;
-}
-// adapted from adapter-utils untrustedIsObject
-function isObject(value) {
-    return typeof value === 'object' && value !== null && isArray(value) === false;
-}
-function stringifyIfPresent(value) {
-    if (value === undefined || value === null) {
-        return null;
-    }
-    return stringify(value);
-}
-function parseIfPresent(value) {
-    if (value === undefined || value === null || value === '') {
-        return null;
-    }
-    return parse(value);
-}
-function buildNimbusNetworkPluginRequest(resourceRequest, resourceRequestContext) {
-    const { basePath, baseUri, method, headers, queryParams, body } = resourceRequest;
-    let observabilityContext = null;
-    if (resourceRequestContext !== undefined &&
-        resourceRequestContext.requestCorrelator !== undefined &&
-        resourceRequestContext.requestCorrelator.observabilityContext !==
-            undefined) {
-        ({ observabilityContext = null } =
-            resourceRequestContext.requestCorrelator);
-    }
-    return {
-        method: methodFromResourceRequestMethod(method),
-        body: stringifyIfPresent(body),
-        headers,
-        queryParams: ldsParamsToString(queryParams),
-        path: `${baseUri}${basePath}`,
-        priority: priorityFromResourceRequest(resourceRequest),
-        observabilityContext,
-    };
-}
-function buildLdsResponse(response) {
-    const { body: responseBody, headers, status } = response;
-    const statusText = statusTextFromStatusCode(status);
-    return {
-        statusText,
-        status,
-        body: parseIfPresent(responseBody),
-        headers,
-        ok: isStatusOk(status),
-    };
+function ldsParamsToString(params) {
+    const returnParams = create(null);
+    const keys$1 = keys(params);
+    for (let i = 0, len = keys$1.length; i < len; i++) {
+        const key = keys$1[i];
+        const value = params[key];
+        if (value === undefined) {
+            // filter out params that have no value
+            continue;
+        }
+        if (isArray(value)) {
+            // filter out empty arrays
+            if (value.length > 0) {
+                returnParams[key] = value.join(',');
+            }
+        }
+        else {
+            returnParams[key] = `${value}`;
+        }
+        if (isObject(value) === true && keys(value).length > 0) {
+            returnParams[key] = stringify(value);
+        }
+    }
+    return returnParams;
+}
+function statusTextFromStatusCode(status) {
+    switch (status) {
+        case HttpStatusCode.Ok:
+            return 'OK';
+        case HttpStatusCode.NotModified:
+            return 'Not Modified';
+        case HttpStatusCode.NotFound:
+            return 'Not Found';
+        case HttpStatusCode.BadRequest:
+            return 'Bad Request';
+        case HttpStatusCode.ServerError:
+            return 'Server Error';
+        default:
+            return `Unexpected HTTP Status Code: ${status}`;
+    }
+}
+function methodFromResourceRequestMethod(method) {
+    switch (method.toLowerCase()) {
+        case 'get':
+            return 'GET';
+        case 'put':
+            return 'PUT';
+        case 'post':
+            return 'POST';
+        case 'delete':
+            return 'DELETE';
+        case 'patch':
+            return 'PATCH';
+        default:
+            throw Error(`Unexpected method ${method}`);
+    }
+}
+function priorityFromResourceRequest(request) {
+    switch (request.priority) {
+        case 'background':
+            return 'background';
+        case 'high':
+            return 'high';
+        case 'normal':
+        default:
+            return 'normal';
+    }
+}
+function isStatusOk(status) {
+    return status >= 200 && status <= 299;
+}
+// adapted from adapter-utils untrustedIsObject
+function isObject(value) {
+    return typeof value === 'object' && value !== null && isArray(value) === false;
+}
+function stringifyIfPresent(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    return stringify(value);
+}
+function parseIfPresent(value) {
+    if (value === undefined || value === null || value === '') {
+        return null;
+    }
+    return parse(value);
+}
+function buildNimbusNetworkPluginRequest(resourceRequest, resourceRequestContext) {
+    const { basePath, baseUri, method, headers, queryParams, body } = resourceRequest;
+    let observabilityContext = null;
+    if (resourceRequestContext !== undefined &&
+        resourceRequestContext.requestCorrelator !== undefined &&
+        resourceRequestContext.requestCorrelator.observabilityContext !==
+            undefined) {
+        ({ observabilityContext = null } =
+            resourceRequestContext.requestCorrelator);
+    }
+    return {
+        method: methodFromResourceRequestMethod(method),
+        body: stringifyIfPresent(body),
+        headers,
+        queryParams: ldsParamsToString(queryParams),
+        path: `${baseUri}${basePath}`,
+        priority: priorityFromResourceRequest(resourceRequest),
+        observabilityContext,
+    };
+}
+function buildLdsResponse(response) {
+    const { body: responseBody, headers, status } = response;
+    const statusText = statusTextFromStatusCode(status);
+    return {
+        statusText,
+        status,
+        body: parseIfPresent(responseBody),
+        headers,
+        ok: isStatusOk(status),
+    };
 }
 
-// so eslint doesn't complain about nimbus
-const tasker = idleDetector.declareNotifierTaskMulti('NimbusNetworkAdapter');
-const NimbusNetworkAdapter = (request, resourceRequestContext) => {
-    tasker.add();
-    return new Promise((resolve, reject) => {
-        try {
-            __nimbus.plugins.LdsNetworkAdapter.sendRequest(buildNimbusNetworkPluginRequest(request, resourceRequestContext), (response) => {
-                try {
-                    resolve(buildLdsResponse(response));
-                }
-                catch (error) {
-                    // don't leave promise hanging, catch any errors (eg: if native side
-                    // returns malformed response) and call reject
-                    reject(error);
-                }
-            }, (error) => {
-                reject(new Error(`type: ${error.type}, message: ${error.message}`));
-            });
-        }
-        catch (error) {
-            // don't leave promise hanging, catch any errors (eg: if native side
-            // fails to parse the request), and call reject
-            reject(error);
-        }
-    }).finally(() => tasker.done());
+// so eslint doesn't complain about nimbus
+const tasker = idleDetector.declareNotifierTaskMulti('NimbusNetworkAdapter');
+const NimbusNetworkAdapter = (request, resourceRequestContext) => {
+    tasker.add();
+    return new Promise((resolve, reject) => {
+        try {
+            __nimbus.plugins.LdsNetworkAdapter.sendRequest(buildNimbusNetworkPluginRequest(request, resourceRequestContext), (response) => {
+                try {
+                    resolve(buildLdsResponse(response));
+                }
+                catch (error) {
+                    // don't leave promise hanging, catch any errors (eg: if native side
+                    // returns malformed response) and call reject
+                    reject(error);
+                }
+            }, (error) => {
+                reject(new Error(`type: ${error.type}, message: ${error.message}`));
+            });
+        }
+        catch (error) {
+            // don't leave promise hanging, catch any errors (eg: if native side
+            // fails to parse the request), and call reject
+            reject(error);
+        }
+    }).finally(() => tasker.done());
 };
 
-/**
- * related-list-records/batch fields and optional fields could be like below.
- * /ui-api/related-list-records/batch/001R0000006l1xKIAQ/Contacts,Opportunities?
- * optionalFields=Contacts:Contact.Id,Contact.Name;Opportunities:Opportunity.Id
- *
- * the pattern is [{relativeListId}:{[fields]};{relativeListId}:{[fields]}]
- */
-const SEPARATOR_BETWEEN_SCOPES = ';';
-const SEPARATOR_BETWEEN_SCOPE_AND_FIELDS = ':';
-const SEPARATOR_BETWEEN_FIELDS = ',';
-const UNSCOPED_IDENTIFIER = 'unscoped';
-class ScopedFields {
-    constructor(scope, fields) {
-        this.fields = {};
-        this.scope = scope;
-        for (let i = 0, len = fields.length; i < len; i += 1) {
-            this.fields[fields[i]] = true;
-        }
-    }
-    isUnScoped() {
-        return this.scope === UNSCOPED_IDENTIFIER;
-    }
-    addField(field) {
-        this.fields[field] = true;
-    }
-    addFields(fields) {
-        fields.forEach(this.addField, this);
-    }
-    toQueryParameterValue() {
-        const joinedFields = join.call(Object.keys(this.fields), SEPARATOR_BETWEEN_FIELDS);
-        return this.isUnScoped()
-            ? joinedFields
-            : join.call([this.scope, joinedFields], SEPARATOR_BETWEEN_SCOPE_AND_FIELDS);
-    }
-    toQueryParams() {
-        return this.isUnScoped() ? Object.keys(this.fields) : this.toQueryParameterValue();
-    }
-    /**
-     * parse Contacts:Contact.Id,Contact.Name into a QueryFields
-     */
-    static fromQueryParameterValue(paramValue) {
-        if (paramValue === null || paramValue === '')
-            return;
-        const scopeToFields = paramValue.split(SEPARATOR_BETWEEN_SCOPE_AND_FIELDS);
-        if (scopeToFields.length === 1) {
-            //unscoped
-            return new ScopedFields(UNSCOPED_IDENTIFIER, scopeToFields[0].split(SEPARATOR_BETWEEN_FIELDS));
-        }
-        else if (scopeToFields.length === 2) {
-            const scope = scopeToFields[0];
-            const fields = scopeToFields[1];
-            if (scope === undefined || fields === null)
-                return;
-            return new ScopedFields(scope, fields.split(SEPARATOR_BETWEEN_FIELDS));
-        }
-        else {
-            return;
-        }
-    }
-}
-class ScopedFieldsCollection {
-    constructor() {
-        this.listIdToFieldsMap = {};
-    }
-    /**
-     * merge the from ScopedFieldsCollection into current one
-     * @param from
-     */
-    merge(from) {
-        const { listIdToFieldsMap } = from;
-        const scopes = Object.keys(listIdToFieldsMap);
-        for (let i = 0, len = scopes.length; i < len; i += 1) {
-            const scope = scopes[i];
-            const scopedFields = listIdToFieldsMap[scope];
-            const existingScopedFields = this.listIdToFieldsMap[scope];
-            if (existingScopedFields) {
-                existingScopedFields.addFields(Object.keys(scopedFields.fields));
-            }
-            else {
-                this.listIdToFieldsMap[scope] = scopedFields;
-            }
-        }
-    }
-    toQueryParams() {
-        return this.countOfUnScoped() > 0
-            ? this.listIdToFieldsMap[UNSCOPED_IDENTIFIER].toQueryParams()
-            : this.toQueryParameterValue();
-    }
-    /**
-     * convert to query parameter value
-     * @returns
-     */
-    toQueryParameterValue() {
-        let result = [];
-        const scopes = Object.keys(this.listIdToFieldsMap);
-        for (let i = 0, len = scopes.length; i < len; i += 1) {
-            const chunk = this.listIdToFieldsMap[scopes[i]].toQueryParameterValue();
-            if (chunk !== undefined)
-                result.push(chunk);
-        }
-        return join.call(result, SEPARATOR_BETWEEN_SCOPES);
-    }
-    /**
-     * split the ScopedFields into multiple ScopedFields
-     * which there max fields list length will not exceeded the specified maxLength
-     * @param maxLength
-     */
-    split(maxLength = MAX_STRING_LENGTH_PER_CHUNK) {
-        const size = this.size();
-        if (size > maxLength) {
-            const fieldsArray = [];
-            const scopes = Object.keys(this.listIdToFieldsMap);
-            for (let i = 0, len = scopes.length; i < len; i += 1) {
-                const { scope, fields } = this.listIdToFieldsMap[scopes[i]];
-                Object.keys(fields).forEach((field) => {
-                    fieldsArray.push([scope, field]);
-                });
-            }
-            // Formula:  # of fields per chunk = floor( max length per chunk / avg field length)
-            const averageFieldStringLength = size / fieldsArray.length;
-            const fieldsPerChunk = Math.floor(maxLength / averageFieldStringLength);
-            let j = fieldsPerChunk;
-            let result = [];
-            let current = null;
-            for (let i = 0, len = fieldsArray.length; i < len; i += 1) {
-                const scope = fieldsArray[i][0];
-                const field = fieldsArray[i][1];
-                if (current === null || !current.listIdToFieldsMap[scope]) {
-                    j = fieldsPerChunk;
-                    current = new ScopedFieldsCollection();
-                    current.listIdToFieldsMap[scope] = new ScopedFields(scope, [field]);
-                    result.push(current);
-                }
-                else {
-                    current.listIdToFieldsMap[scope].addField(field);
-                }
-                j--;
-                if (j === 0) {
-                    current = null;
-                }
-            }
-            return result;
-        }
-        else if (size > 0) {
-            return [this];
-        }
-        else {
-            return [];
-        }
-    }
-    size() {
-        return this.toQueryParameterValue().length;
-    }
-    countOfUnScoped() {
-        let count = 0;
-        const fieldsArray = Object.values(this.listIdToFieldsMap);
-        for (let i = 0, len = fieldsArray.length; i < len; i += 1) {
-            if (fieldsArray[i].isUnScoped()) {
-                count++;
-            }
-        }
-        return count;
-    }
-    countOfScoped() {
-        return Object.keys.length - this.countOfUnScoped();
-    }
-    isUnScopedMixedWithScoped() {
-        return this.countOfUnScoped() > 0 && this.countOfScoped() > 0;
-    }
-    /**
-     *
-     * @param paramValue like Contacts:Contact.Id,Contact.Name;Opportunities:Opportunity.Id
-     * @returns
-     */
-    static fromQueryParameterValue(paramValue) {
-        const result = new ScopedFieldsCollection();
-        if (paramValue) {
-            const relativeListChunks = paramValue.split(SEPARATOR_BETWEEN_SCOPES);
-            if (relativeListChunks.length === 0)
-                return result;
-            for (let i = 0, len = relativeListChunks.length; i < len; i += 1) {
-                const parsed = ScopedFields.fromQueryParameterValue(relativeListChunks[i]);
-                if (parsed) {
-                    result.listIdToFieldsMap[parsed.scope] = parsed;
-                }
-            }
-            if (result.isUnScopedMixedWithScoped()) {
-                throw Error('mixing scoped and unscoped field list is not allowed.');
-            }
-        }
-        return result;
-    }
+/**
+ * related-list-records/batch fields and optional fields could be like below.
+ * /ui-api/related-list-records/batch/001R0000006l1xKIAQ/Contacts,Opportunities?
+ * optionalFields=Contacts:Contact.Id,Contact.Name;Opportunities:Opportunity.Id
+ *
+ * the pattern is [{relativeListId}:{[fields]};{relativeListId}:{[fields]}]
+ */
+const SEPARATOR_BETWEEN_SCOPES = ';';
+const SEPARATOR_BETWEEN_SCOPE_AND_FIELDS = ':';
+const SEPARATOR_BETWEEN_FIELDS = ',';
+const UNSCOPED_IDENTIFIER = 'unscoped';
+class ScopedFields {
+    constructor(scope, fields) {
+        this.fields = {};
+        this.scope = scope;
+        for (let i = 0, len = fields.length; i < len; i += 1) {
+            this.fields[fields[i]] = true;
+        }
+    }
+    isUnScoped() {
+        return this.scope === UNSCOPED_IDENTIFIER;
+    }
+    addField(field) {
+        this.fields[field] = true;
+    }
+    addFields(fields) {
+        fields.forEach(this.addField, this);
+    }
+    toQueryParameterValue() {
+        const joinedFields = join.call(Object.keys(this.fields), SEPARATOR_BETWEEN_FIELDS);
+        return this.isUnScoped()
+            ? joinedFields
+            : join.call([this.scope, joinedFields], SEPARATOR_BETWEEN_SCOPE_AND_FIELDS);
+    }
+    toQueryParams() {
+        return this.isUnScoped() ? Object.keys(this.fields) : this.toQueryParameterValue();
+    }
+    /**
+     * parse Contacts:Contact.Id,Contact.Name into a QueryFields
+     */
+    static fromQueryParameterValue(paramValue) {
+        if (paramValue === null || paramValue === '')
+            return;
+        const scopeToFields = paramValue.split(SEPARATOR_BETWEEN_SCOPE_AND_FIELDS);
+        if (scopeToFields.length === 1) {
+            //unscoped
+            return new ScopedFields(UNSCOPED_IDENTIFIER, scopeToFields[0].split(SEPARATOR_BETWEEN_FIELDS));
+        }
+        else if (scopeToFields.length === 2) {
+            const scope = scopeToFields[0];
+            const fields = scopeToFields[1];
+            if (scope === undefined || fields === null)
+                return;
+            return new ScopedFields(scope, fields.split(SEPARATOR_BETWEEN_FIELDS));
+        }
+        else {
+            return;
+        }
+    }
+}
+class ScopedFieldsCollection {
+    constructor() {
+        this.listIdToFieldsMap = {};
+    }
+    /**
+     * merge the from ScopedFieldsCollection into current one
+     * @param from
+     */
+    merge(from) {
+        const { listIdToFieldsMap } = from;
+        const scopes = Object.keys(listIdToFieldsMap);
+        for (let i = 0, len = scopes.length; i < len; i += 1) {
+            const scope = scopes[i];
+            const scopedFields = listIdToFieldsMap[scope];
+            const existingScopedFields = this.listIdToFieldsMap[scope];
+            if (existingScopedFields) {
+                existingScopedFields.addFields(Object.keys(scopedFields.fields));
+            }
+            else {
+                this.listIdToFieldsMap[scope] = scopedFields;
+            }
+        }
+    }
+    toQueryParams() {
+        return this.countOfUnScoped() > 0
+            ? this.listIdToFieldsMap[UNSCOPED_IDENTIFIER].toQueryParams()
+            : this.toQueryParameterValue();
+    }
+    /**
+     * convert to query parameter value
+     * @returns
+     */
+    toQueryParameterValue() {
+        let result = [];
+        const scopes = Object.keys(this.listIdToFieldsMap);
+        for (let i = 0, len = scopes.length; i < len; i += 1) {
+            const chunk = this.listIdToFieldsMap[scopes[i]].toQueryParameterValue();
+            if (chunk !== undefined)
+                result.push(chunk);
+        }
+        return join.call(result, SEPARATOR_BETWEEN_SCOPES);
+    }
+    /**
+     * split the ScopedFields into multiple ScopedFields
+     * which there max fields list length will not exceeded the specified maxLength
+     * @param maxLength
+     */
+    split(maxLength = MAX_STRING_LENGTH_PER_CHUNK) {
+        const size = this.size();
+        if (size > maxLength) {
+            const fieldsArray = [];
+            const scopes = Object.keys(this.listIdToFieldsMap);
+            for (let i = 0, len = scopes.length; i < len; i += 1) {
+                const { scope, fields } = this.listIdToFieldsMap[scopes[i]];
+                Object.keys(fields).forEach((field) => {
+                    fieldsArray.push([scope, field]);
+                });
+            }
+            // Formula:  # of fields per chunk = floor( max length per chunk / avg field length)
+            const averageFieldStringLength = size / fieldsArray.length;
+            const fieldsPerChunk = Math.floor(maxLength / averageFieldStringLength);
+            let j = fieldsPerChunk;
+            let result = [];
+            let current = null;
+            for (let i = 0, len = fieldsArray.length; i < len; i += 1) {
+                const scope = fieldsArray[i][0];
+                const field = fieldsArray[i][1];
+                if (current === null || !current.listIdToFieldsMap[scope]) {
+                    j = fieldsPerChunk;
+                    current = new ScopedFieldsCollection();
+                    current.listIdToFieldsMap[scope] = new ScopedFields(scope, [field]);
+                    result.push(current);
+                }
+                else {
+                    current.listIdToFieldsMap[scope].addField(field);
+                }
+                j--;
+                if (j === 0) {
+                    current = null;
+                }
+            }
+            return result;
+        }
+        else if (size > 0) {
+            return [this];
+        }
+        else {
+            return [];
+        }
+    }
+    size() {
+        return this.toQueryParameterValue().length;
+    }
+    countOfUnScoped() {
+        let count = 0;
+        const fieldsArray = Object.values(this.listIdToFieldsMap);
+        for (let i = 0, len = fieldsArray.length; i < len; i += 1) {
+            if (fieldsArray[i].isUnScoped()) {
+                count++;
+            }
+        }
+        return count;
+    }
+    countOfScoped() {
+        return Object.keys.length - this.countOfUnScoped();
+    }
+    isUnScopedMixedWithScoped() {
+        return this.countOfUnScoped() > 0 && this.countOfScoped() > 0;
+    }
+    /**
+     *
+     * @param paramValue like Contacts:Contact.Id,Contact.Name;Opportunities:Opportunity.Id
+     * @returns
+     */
+    static fromQueryParameterValue(paramValue) {
+        const result = new ScopedFieldsCollection();
+        if (paramValue) {
+            const relativeListChunks = paramValue.split(SEPARATOR_BETWEEN_SCOPES);
+            if (relativeListChunks.length === 0)
+                return result;
+            for (let i = 0, len = relativeListChunks.length; i < len; i += 1) {
+                const parsed = ScopedFields.fromQueryParameterValue(relativeListChunks[i]);
+                if (parsed) {
+                    result.listIdToFieldsMap[parsed.scope] = parsed;
+                }
+            }
+            if (result.isUnScopedMixedWithScoped()) {
+                throw Error('mixing scoped and unscoped field list is not allowed.');
+            }
+        }
+        return result;
+    }
 }
 
-const MAX_STRING_LENGTH_PER_CHUNK = 10000;
-const PARSE_ERROR = 'PARSE_AGGREGATE_UI_RESPONSE_ERROR';
-function isErrorResponse(response) {
-    return response.httpStatusCode >= 400;
-}
-/**
- * merge the aggregate ui child responses into a single object representation
- * @param response
- * @param mergeFunc the function used to define how the records should be merged together
- * @returns the merged record
- */
-function mergeAggregateUiResponse(response, mergeFunc) {
-    const { body } = response;
-    try {
-        if (body === null ||
-            body === undefined ||
-            body.compositeResponse === undefined ||
-            body.compositeResponse.length === 0) {
-            // We shouldn't even get into this state - a 200 with no body?
-            // eslint-disable-next-line @salesforce/lds/no-error-in-production
-            throw new Error('No response body in executeAggregateUi found');
-        }
-        // if the body has any non-2xx statuses then that's an error and we return
-        // the network response with that error
-        const error = body.compositeResponse.find(isErrorResponse);
-        if (error !== undefined) {
-            const { httpStatusCode, body: errorBody } = error;
-            const statusText = errorBody.length > 0 ? errorBody[0].errorCode : '';
-            return {
-                ...response,
-                ok: false,
-                status: httpStatusCode,
-                statusText,
-                body: errorBody,
-            };
-        }
-        // if we got here there are no errors in body, cast as such
-        const responses = body.compositeResponse;
-        const merged = responses.reduce((seed, resp) => {
-            if (seed === null) {
-                return resp.body;
-            }
-            return mergeFunc(seed, resp.body);
-        }, null);
-        return {
-            ...response,
-            body: merged,
-        };
-    }
-    catch (error) {
-        return {
-            ...response,
-            ok: false,
-            status: HttpStatusCode.ServerError,
-            statusText: PARSE_ERROR,
-            body: [
-                {
-                    errorCode: PARSE_ERROR,
-                    message: error.toString(),
-                },
-            ],
-        };
-    }
-}
-function buildAggregateUiUrl(params, resourceRequest) {
-    const { fields, optionalFields } = params;
-    const mergedParams = {
-        ...resourceRequest.queryParams,
-        fields,
-        optionalFields,
-    };
-    const queryString = [];
-    for (const [key, value] of entries(mergedParams)) {
-        if (value !== undefined) {
-            queryString.push(`${key}=${isArray(value) ? value.join(',') : value}`);
-        }
-    }
-    return `${resourceRequest.baseUri}${resourceRequest.basePath}?${join.call(queryString, '&')}`;
-}
-function shouldUseAggregateUiForFields(fieldsArray, optionalFieldsArray) {
-    return fieldsArray.length + optionalFieldsArray.length >= MAX_STRING_LENGTH_PER_CHUNK;
-}
-function isSpanningRecord(fieldValue) {
-    return fieldValue !== null && typeof fieldValue === 'object';
-}
-function mergeRecordFields(first, second) {
-    const { fields: targetFields } = first;
-    const { fields: sourceFields } = second;
-    const fieldNames = keys(sourceFields);
-    for (let i = 0, len = fieldNames.length; i < len; i += 1) {
-        const fieldName = fieldNames[i];
-        const sourceField = sourceFields[fieldName];
-        const targetField = targetFields[fieldName];
-        if (isSpanningRecord(sourceField.value)) {
-            if (targetField === undefined) {
-                targetFields[fieldName] = sourceField;
-                continue;
-            }
-            mergeRecordFields(targetField.value, sourceField.value);
-            continue;
-        }
-        targetFields[fieldName] = sourceField;
-    }
-    return first;
-}
-function mergeBatchRecordsFields(first, second, collectionMergeFunc) {
-    const { results: targetResults } = first;
-    const { results: sourceResults } = second;
-    for (let i = 0, len = targetResults.length; i < len; i += 1) {
-        const targetResult = targetResults[i];
-        const sourceResult = sourceResults[i];
-        if (targetResult.statusCode !== HttpStatusCode.Ok)
-            continue;
-        if (sourceResult.statusCode !== HttpStatusCode.Ok) {
-            targetResults[i] = sourceResult;
-            continue;
-        }
-        collectionMergeFunc(targetResult.result, sourceResult.result);
-    }
-    return first;
-}
-/**
- * Check to see if we have fields that are > max allowed characters long
- * @param resourceRequest resource request to check
- * @param endpoint Regular Expression to check the endpoint to aggregate
- * @returns undefined if we should not aggregate. object if we should.
- */
-function createAggregateBatchRequestInfo(resourceRequest, endpoint) {
-    // only handle GETs on the given endpoint regex
-    if (!isGetRequestForEndpoint(endpoint, resourceRequest)) {
-        return undefined;
-    }
-    const { queryParams: { fields, optionalFields }, } = resourceRequest;
-    // only handle requests with fields or optional fields
-    if (fields === undefined && optionalFields === undefined) {
-        return undefined;
-    }
-    const fieldsArray = arrayOrEmpty(fields);
-    const optionalFieldsArray = arrayOrEmpty(optionalFields);
-    // if fields and optional fields are empty delegate request
-    if (fieldsArray.length === 0 && optionalFieldsArray.length === 0) {
-        return undefined;
-    }
-    const fieldsString = fieldsArray.join(',');
-    const optionalFieldsString = optionalFieldsArray.join(',');
-    const shouldUseAggregate = shouldUseAggregateUiForFields(fieldsString, optionalFieldsString);
-    if (!shouldUseAggregate) {
-        return undefined;
-    }
-    const fieldCollection = ScopedFieldsCollection.fromQueryParameterValue(fieldsString).split(MAX_STRING_LENGTH_PER_CHUNK);
-    const optionalFieldCollection = ScopedFieldsCollection.fromQueryParameterValue(optionalFieldsString).split(MAX_STRING_LENGTH_PER_CHUNK);
-    return {
-        fieldCollection,
-        optionalFieldCollection,
-    };
-}
-function createAggregateUiRequest(resourceRequest, compositeRequest) {
-    const aggregateUiPostBody = { compositeRequest };
-    const aggregateResourceRequest = {
-        method: 'post',
-        baseUri: resourceRequest.baseUri,
-        basePath: '/ui-api/aggregate-ui',
-        body: aggregateUiPostBody,
-        priority: resourceRequest.priority,
-        queryParams: {},
-        headers: {},
-        urlParams: {},
-    };
-    return aggregateResourceRequest;
-}
-function buildCompositeRequestByFields(referenceId, resourceRequest, recordsCompositeRequest) {
-    const { fieldCollection, optionalFieldCollection } = recordsCompositeRequest;
-    const compositeRequest = [];
-    if (fieldCollection !== undefined) {
-        for (let i = 0, len = fieldCollection.length; i < len; i += 1) {
-            const fieldChunk = fieldCollection[i].toQueryParams();
-            if (fieldChunk.length === 0) {
-                continue;
-            }
-            const url = buildAggregateUiUrl({
-                fields: fieldChunk,
-            }, resourceRequest);
-            push.call(compositeRequest, {
-                url,
-                referenceId: `${referenceId}_fields_${i}`,
-            });
-        }
-    }
-    if (optionalFieldCollection !== undefined) {
-        for (let i = 0, len = optionalFieldCollection.length; i < len; i += 1) {
-            const fieldChunk = optionalFieldCollection[i].toQueryParams();
-            if (fieldChunk.length === 0) {
-                continue;
-            }
-            const url = buildAggregateUiUrl({
-                optionalFields: fieldChunk,
-            }, resourceRequest);
-            push.call(compositeRequest, {
-                url,
-                referenceId: `${referenceId}_optionalFields_${i}`,
-            });
-        }
-    }
-    return compositeRequest;
-}
-/**
- * Checks if a resource request is a GET method on the given endpoint
- * @param endpoint Regular Expression of the endpoint
- * @param request the resource request
- */
-function isGetRequestForEndpoint(endpoint, request) {
-    const { basePath, method } = request;
-    return endpoint.test(basePath) && method === 'get';
-}
-/**
- * Checks if any is an array and returns it as an array.
- * if not an array it returns an empty array.
- * @param array the item to check is an array
- * @returns the array or an empty array
- */
-function arrayOrEmpty(array) {
-    return array !== undefined && isArray(array) ? array : [];
+const MAX_STRING_LENGTH_PER_CHUNK = 10000;
+const PARSE_ERROR = 'PARSE_AGGREGATE_UI_RESPONSE_ERROR';
+function isErrorResponse(response) {
+    return response.httpStatusCode >= 400;
+}
+/**
+ * merge the aggregate ui child responses into a single object representation
+ * @param response
+ * @param mergeFunc the function used to define how the records should be merged together
+ * @returns the merged record
+ */
+function mergeAggregateUiResponse(response, mergeFunc) {
+    const { body } = response;
+    try {
+        if (body === null ||
+            body === undefined ||
+            body.compositeResponse === undefined ||
+            body.compositeResponse.length === 0) {
+            // We shouldn't even get into this state - a 200 with no body?
+            // eslint-disable-next-line @salesforce/lds/no-error-in-production
+            throw new Error('No response body in executeAggregateUi found');
+        }
+        // if the body has any non-2xx statuses then that's an error and we return
+        // the network response with that error
+        const error = body.compositeResponse.find(isErrorResponse);
+        if (error !== undefined) {
+            const { httpStatusCode, body: errorBody } = error;
+            const statusText = errorBody.length > 0 ? errorBody[0].errorCode : '';
+            return {
+                ...response,
+                ok: false,
+                status: httpStatusCode,
+                statusText,
+                body: errorBody,
+            };
+        }
+        // if we got here there are no errors in body, cast as such
+        const responses = body.compositeResponse;
+        const merged = responses.reduce((seed, resp) => {
+            if (seed === null) {
+                return resp.body;
+            }
+            return mergeFunc(seed, resp.body);
+        }, null);
+        return {
+            ...response,
+            body: merged,
+        };
+    }
+    catch (error) {
+        return {
+            ...response,
+            ok: false,
+            status: HttpStatusCode.ServerError,
+            statusText: PARSE_ERROR,
+            body: [
+                {
+                    errorCode: PARSE_ERROR,
+                    message: error.toString(),
+                },
+            ],
+        };
+    }
+}
+function buildAggregateUiUrl(params, resourceRequest) {
+    const { fields, optionalFields } = params;
+    const mergedParams = {
+        ...resourceRequest.queryParams,
+        fields,
+        optionalFields,
+    };
+    const queryString = [];
+    for (const [key, value] of entries(mergedParams)) {
+        if (value !== undefined) {
+            queryString.push(`${key}=${isArray(value) ? value.join(',') : value}`);
+        }
+    }
+    return `${resourceRequest.baseUri}${resourceRequest.basePath}?${join.call(queryString, '&')}`;
+}
+function shouldUseAggregateUiForFields(fieldsArray, optionalFieldsArray) {
+    return fieldsArray.length + optionalFieldsArray.length >= MAX_STRING_LENGTH_PER_CHUNK;
+}
+function isSpanningRecord(fieldValue) {
+    return fieldValue !== null && typeof fieldValue === 'object';
+}
+function mergeRecordFields(first, second) {
+    const { fields: targetFields } = first;
+    const { fields: sourceFields } = second;
+    const fieldNames = keys(sourceFields);
+    for (let i = 0, len = fieldNames.length; i < len; i += 1) {
+        const fieldName = fieldNames[i];
+        const sourceField = sourceFields[fieldName];
+        const targetField = targetFields[fieldName];
+        if (isSpanningRecord(sourceField.value)) {
+            if (targetField === undefined) {
+                targetFields[fieldName] = sourceField;
+                continue;
+            }
+            mergeRecordFields(targetField.value, sourceField.value);
+            continue;
+        }
+        targetFields[fieldName] = sourceField;
+    }
+    return first;
+}
+function mergeBatchRecordsFields(first, second, collectionMergeFunc) {
+    const { results: targetResults } = first;
+    const { results: sourceResults } = second;
+    for (let i = 0, len = targetResults.length; i < len; i += 1) {
+        const targetResult = targetResults[i];
+        const sourceResult = sourceResults[i];
+        if (targetResult.statusCode !== HttpStatusCode.Ok)
+            continue;
+        if (sourceResult.statusCode !== HttpStatusCode.Ok) {
+            targetResults[i] = sourceResult;
+            continue;
+        }
+        collectionMergeFunc(targetResult.result, sourceResult.result);
+    }
+    return first;
+}
+/**
+ * Check to see if we have fields that are > max allowed characters long
+ * @param resourceRequest resource request to check
+ * @param endpoint Regular Expression to check the endpoint to aggregate
+ * @returns undefined if we should not aggregate. object if we should.
+ */
+function createAggregateBatchRequestInfo(resourceRequest, endpoint) {
+    // only handle GETs on the given endpoint regex
+    if (!isGetRequestForEndpoint(endpoint, resourceRequest)) {
+        return undefined;
+    }
+    const { queryParams: { fields, optionalFields }, } = resourceRequest;
+    // only handle requests with fields or optional fields
+    if (fields === undefined && optionalFields === undefined) {
+        return undefined;
+    }
+    const fieldsArray = arrayOrEmpty(fields);
+    const optionalFieldsArray = arrayOrEmpty(optionalFields);
+    // if fields and optional fields are empty delegate request
+    if (fieldsArray.length === 0 && optionalFieldsArray.length === 0) {
+        return undefined;
+    }
+    const fieldsString = fieldsArray.join(',');
+    const optionalFieldsString = optionalFieldsArray.join(',');
+    const shouldUseAggregate = shouldUseAggregateUiForFields(fieldsString, optionalFieldsString);
+    if (!shouldUseAggregate) {
+        return undefined;
+    }
+    const fieldCollection = ScopedFieldsCollection.fromQueryParameterValue(fieldsString).split(MAX_STRING_LENGTH_PER_CHUNK);
+    const optionalFieldCollection = ScopedFieldsCollection.fromQueryParameterValue(optionalFieldsString).split(MAX_STRING_LENGTH_PER_CHUNK);
+    return {
+        fieldCollection,
+        optionalFieldCollection,
+    };
+}
+function createAggregateUiRequest(resourceRequest, compositeRequest) {
+    const aggregateUiPostBody = { compositeRequest };
+    const aggregateResourceRequest = {
+        method: 'post',
+        baseUri: resourceRequest.baseUri,
+        basePath: '/ui-api/aggregate-ui',
+        body: aggregateUiPostBody,
+        priority: resourceRequest.priority,
+        queryParams: {},
+        headers: {},
+        urlParams: {},
+    };
+    return aggregateResourceRequest;
+}
+function buildCompositeRequestByFields(referenceId, resourceRequest, recordsCompositeRequest) {
+    const { fieldCollection, optionalFieldCollection } = recordsCompositeRequest;
+    const compositeRequest = [];
+    if (fieldCollection !== undefined) {
+        for (let i = 0, len = fieldCollection.length; i < len; i += 1) {
+            const fieldChunk = fieldCollection[i].toQueryParams();
+            if (fieldChunk.length === 0) {
+                continue;
+            }
+            const url = buildAggregateUiUrl({
+                fields: fieldChunk,
+            }, resourceRequest);
+            push.call(compositeRequest, {
+                url,
+                referenceId: `${referenceId}_fields_${i}`,
+            });
+        }
+    }
+    if (optionalFieldCollection !== undefined) {
+        for (let i = 0, len = optionalFieldCollection.length; i < len; i += 1) {
+            const fieldChunk = optionalFieldCollection[i].toQueryParams();
+            if (fieldChunk.length === 0) {
+                continue;
+            }
+            const url = buildAggregateUiUrl({
+                optionalFields: fieldChunk,
+            }, resourceRequest);
+            push.call(compositeRequest, {
+                url,
+                referenceId: `${referenceId}_optionalFields_${i}`,
+            });
+        }
+    }
+    return compositeRequest;
+}
+/**
+ * Checks if a resource request is a GET method on the given endpoint
+ * @param endpoint Regular Expression of the endpoint
+ * @param request the resource request
+ */
+function isGetRequestForEndpoint(endpoint, request) {
+    const { basePath, method } = request;
+    return endpoint.test(basePath) && method === 'get';
+}
+/**
+ * Checks if any is an array and returns it as an array.
+ * if not an array it returns an empty array.
+ * @param array the item to check is an array
+ * @returns the array or an empty array
+ */
+function arrayOrEmpty(array) {
+    return array !== undefined && isArray(array) ? array : [];
 }
 
-const RECORD_ENDPOINT_REGEX = /^\/ui-api\/records\/?(([a-zA-Z0-9]+))?$/;
-const referenceId$3 = 'LDS_Records_AggregateUi';
-/**
- * Export to facilitate unit tests
- * Merge the second getRecord result into the first one.
- * If any is error response, merged result is error response.
- * If both are sucesses, due to they are from same records,
- * fields sub node will be merged recursively
- */
-function mergeGetRecordResult(first, second) {
-    // return the error if first is error.
-    if (isArray(first) && !isArray(second))
-        return first;
-    // return the error if second is error.
-    if (!isArray(first) && isArray(second))
-        return second;
-    // concat the error array if both are error
-    if (isArray(first) && isArray(second)) {
-        return [...first, ...second];
-    }
-    mergeRecordFields(first, second);
-    return first;
-}
-function makeNetworkChunkFieldsGetRecord(networkAdapter) {
-    return (resourceRequest, resourceRequestContext) => {
-        const batchRequestInfo = createAggregateBatchRequestInfo(resourceRequest, RECORD_ENDPOINT_REGEX);
-        if (batchRequestInfo === undefined) {
-            return networkAdapter(resourceRequest, resourceRequestContext);
-        }
-        const compositeRequest = buildCompositeRequestByFields(referenceId$3, resourceRequest, batchRequestInfo);
-        const aggregateRequest = createAggregateUiRequest(resourceRequest, compositeRequest);
-        return networkAdapter(aggregateRequest, resourceRequestContext).then((response) => {
-            return mergeAggregateUiResponse(response, mergeGetRecordResult);
-        });
-    };
+const RECORD_ENDPOINT_REGEX = /^\/ui-api\/records\/?(([a-zA-Z0-9]+))?$/;
+const referenceId$3 = 'LDS_Records_AggregateUi';
+/**
+ * Export to facilitate unit tests
+ * Merge the second getRecord result into the first one.
+ * If any is error response, merged result is error response.
+ * If both are sucesses, due to they are from same records,
+ * fields sub node will be merged recursively
+ */
+function mergeGetRecordResult(first, second) {
+    // return the error if first is error.
+    if (isArray(first) && !isArray(second))
+        return first;
+    // return the error if second is error.
+    if (!isArray(first) && isArray(second))
+        return second;
+    // concat the error array if both are error
+    if (isArray(first) && isArray(second)) {
+        return [...first, ...second];
+    }
+    mergeRecordFields(first, second);
+    return first;
+}
+function makeNetworkChunkFieldsGetRecord(networkAdapter) {
+    return (resourceRequest, resourceRequestContext) => {
+        const batchRequestInfo = createAggregateBatchRequestInfo(resourceRequest, RECORD_ENDPOINT_REGEX);
+        if (batchRequestInfo === undefined) {
+            return networkAdapter(resourceRequest, resourceRequestContext);
+        }
+        const compositeRequest = buildCompositeRequestByFields(referenceId$3, resourceRequest, batchRequestInfo);
+        const aggregateRequest = createAggregateUiRequest(resourceRequest, compositeRequest);
+        return networkAdapter(aggregateRequest, resourceRequestContext).then((response) => {
+            return mergeAggregateUiResponse(response, mergeGetRecordResult);
+        });
+    };
 }
 
-const RECORDS_BATCH_ENDPOINT_REGEX = /^\/ui-api\/records\/batch\/?(([a-zA-Z0-9|,]+))?$/;
-const referenceId$2 = 'LDS_Records_Batch_AggregateUi';
-function makeNetworkChunkFieldsGetRecordsBatch(networkAdapter) {
-    return (resourceRequest, resourceRequestContext) => {
-        const batchRequestInfo = createAggregateBatchRequestInfo(resourceRequest, RECORDS_BATCH_ENDPOINT_REGEX);
-        if (batchRequestInfo === undefined) {
-            return networkAdapter(resourceRequest, resourceRequestContext);
-        }
-        const compositeRequest = buildCompositeRequestByFields(referenceId$2, resourceRequest, batchRequestInfo);
-        const aggregateRequest = createAggregateUiRequest(resourceRequest, compositeRequest);
-        return networkAdapter(aggregateRequest, resourceRequestContext).then((response) => {
-            return mergeAggregateUiResponse(response, (first, second) => {
-                return mergeBatchRecordsFields(first, second, (a, b) => {
-                    return mergeRecordFields(a, b);
-                });
-            });
-        });
-    };
+const RECORDS_BATCH_ENDPOINT_REGEX = /^\/ui-api\/records\/batch\/?(([a-zA-Z0-9|,]+))?$/;
+const referenceId$2 = 'LDS_Records_Batch_AggregateUi';
+function makeNetworkChunkFieldsGetRecordsBatch(networkAdapter) {
+    return (resourceRequest, resourceRequestContext) => {
+        const batchRequestInfo = createAggregateBatchRequestInfo(resourceRequest, RECORDS_BATCH_ENDPOINT_REGEX);
+        if (batchRequestInfo === undefined) {
+            return networkAdapter(resourceRequest, resourceRequestContext);
+        }
+        const compositeRequest = buildCompositeRequestByFields(referenceId$2, resourceRequest, batchRequestInfo);
+        const aggregateRequest = createAggregateUiRequest(resourceRequest, compositeRequest);
+        return networkAdapter(aggregateRequest, resourceRequestContext).then((response) => {
+            return mergeAggregateUiResponse(response, (first, second) => {
+                return mergeBatchRecordsFields(first, second, (a, b) => {
+                    return mergeRecordFields(a, b);
+                });
+            });
+        });
+    };
 }
 
-const RELATED_LIST_RECORDS_ENDPOINT_REGEX = /^\/ui-api\/related-list-records\/?(([a-zA-Z0-9]+))?\/?(([a-zA-Z0-9]+))?$/;
-const referenceId$1 = 'LDS_Related_List_Records_AggregateUi';
-const QUERY_KEY_FIELDS = 'fields';
-const QUERY_KEY_OPTIONAL_FIELDS = 'optionalFields';
-/**
- * Merge the second related list record collection into first one and return it.
- * It checks both collections should have exaction same records, otherwise error.
- * Exports it for unit tests
- */
-function mergeRelatedRecordsFields(first, second) {
-    const { records: targetRecords } = first;
-    const { records: sourceRecords } = second;
-    if (sourceRecords.length === targetRecords.length &&
-        recordIdsAllMatch(targetRecords, sourceRecords)) {
-        first.fields = first.fields.concat(second.fields);
-        first.optionalFields = first.optionalFields.concat(second.optionalFields);
-        for (let i = 0, len = sourceRecords.length; i < len; i += 1) {
-            const targetRecord = targetRecords[i];
-            const sourceRecord = sourceRecords[i];
-            mergeRecordFields(targetRecord, sourceRecord);
-        }
-        mergePageUrls(first, second);
-        return first;
-    }
-    else {
-        // Throw error due to two collection are about different set of records
-        // eslint-disable-next-line @salesforce/lds/no-error-in-production
-        throw new Error('Aggregate UI response is invalid');
-    }
-}
-function makeNetworkChunkFieldsGetRelatedListRecords(networkAdapter) {
-    return (resourceRequest, resourceRequestContext) => {
-        const batchRequestInfo = createAggregateBatchRequestInfo(resourceRequest, RELATED_LIST_RECORDS_ENDPOINT_REGEX);
-        if (batchRequestInfo === undefined) {
-            return networkAdapter(resourceRequest, resourceRequestContext);
-        }
-        const compositeRequest = buildCompositeRequestByFields(referenceId$1, resourceRequest, batchRequestInfo);
-        const aggregateRequest = createAggregateUiRequest(resourceRequest, compositeRequest);
-        return networkAdapter(aggregateRequest, resourceRequestContext).then((response) => {
-            return mergeAggregateUiResponse(response, mergeRelatedRecordsFields);
-        });
-    };
-}
-/**
- * merge the second related list record collection into first one and return it
- */
-function mergePageUrls(first, second) {
-    first.currentPageUrl = mergeUrl(first.currentPageUrl, second.currentPageUrl);
-    first.previousPageUrl = mergeUrl(first.previousPageUrl, second.previousPageUrl);
-    first.nextPageUrl = mergeUrl(first.nextPageUrl, second.nextPageUrl);
-}
-/**
- * merge to paging url with different set of fields or optional fields as combined one
- * the paging url is like
- * /services/data/v58.0/ui-api/related-list-records/001R0000006l1xKIAQ/Contacts
- * ?fields=Id%2CName&optionalFields=Contact.Id%2CContact.Name&pageSize=50&pageToken=0
- * @param path1 url path and query parmeter without domain
- * @param path2 url path and query parmeter without domain
- *
- * Export to unit test
- */
-function mergeUrl(path1, path2) {
-    if (path1 === null)
-        return path2;
-    if (path2 === null)
-        return path1;
-    // new Url(...) need the path1, path2 to be prefix-ed with this fake domain
-    const domain = 'http://c.com';
-    const url1 = new URL(domain + path1);
-    const url2 = new URL(domain + path2);
-    const searchParams1 = url1.searchParams;
-    const fields = mergeFields(url1, url2, QUERY_KEY_FIELDS);
-    if (fields && searchParams1.get(QUERY_KEY_FIELDS) !== fields) {
-        searchParams1.set(QUERY_KEY_FIELDS, fields);
-    }
-    const optionalFields = mergeFields(url1, url2, QUERY_KEY_OPTIONAL_FIELDS);
-    if (optionalFields && searchParams1.get(QUERY_KEY_OPTIONAL_FIELDS) !== optionalFields) {
-        searchParams1.set(QUERY_KEY_OPTIONAL_FIELDS, optionalFields);
-    }
-    from(searchParams1.keys())
-        .sort()
-        .forEach((key) => {
-        const value = searchParams1.get(key);
-        searchParams1.delete(key);
-        searchParams1.append(key, value);
-    });
-    return url1.toString().substr(domain.length);
-}
-function mergeFields(url1, url2, name) {
-    const fields1 = ScopedFieldsCollection.fromQueryParameterValue(url1.searchParams.get(name));
-    const fields2 = ScopedFieldsCollection.fromQueryParameterValue(url2.searchParams.get(name));
-    fields1.merge(fields2);
-    return fields1.toQueryParameterValue();
-}
-/**
- * Checks that all records ids exist in both arrays
- * @param first batch of first array or records
- * @param second batch of second array or records
- * @returns
- */
-function recordIdsAllMatch(first, second) {
-    const firstIds = first.map((record) => record.id);
-    const secondIds = second.map((record) => record.id);
-    return firstIds.every((id) => secondIds.includes(id));
+const RELATED_LIST_RECORDS_ENDPOINT_REGEX = /^\/ui-api\/related-list-records\/?(([a-zA-Z0-9]+))?\/?(([a-zA-Z0-9]+))?$/;
+const referenceId$1 = 'LDS_Related_List_Records_AggregateUi';
+const QUERY_KEY_FIELDS = 'fields';
+const QUERY_KEY_OPTIONAL_FIELDS = 'optionalFields';
+/**
+ * Merge the second related list record collection into first one and return it.
+ * It checks both collections should have exaction same records, otherwise error.
+ * Exports it for unit tests
+ */
+function mergeRelatedRecordsFields(first, second) {
+    const { records: targetRecords } = first;
+    const { records: sourceRecords } = second;
+    if (sourceRecords.length === targetRecords.length &&
+        recordIdsAllMatch(targetRecords, sourceRecords)) {
+        first.fields = first.fields.concat(second.fields);
+        first.optionalFields = first.optionalFields.concat(second.optionalFields);
+        for (let i = 0, len = sourceRecords.length; i < len; i += 1) {
+            const targetRecord = targetRecords[i];
+            const sourceRecord = sourceRecords[i];
+            mergeRecordFields(targetRecord, sourceRecord);
+        }
+        mergePageUrls(first, second);
+        return first;
+    }
+    else {
+        // Throw error due to two collection are about different set of records
+        // eslint-disable-next-line @salesforce/lds/no-error-in-production
+        throw new Error('Aggregate UI response is invalid');
+    }
+}
+function makeNetworkChunkFieldsGetRelatedListRecords(networkAdapter) {
+    return (resourceRequest, resourceRequestContext) => {
+        const batchRequestInfo = createAggregateBatchRequestInfo(resourceRequest, RELATED_LIST_RECORDS_ENDPOINT_REGEX);
+        if (batchRequestInfo === undefined) {
+            return networkAdapter(resourceRequest, resourceRequestContext);
+        }
+        const compositeRequest = buildCompositeRequestByFields(referenceId$1, resourceRequest, batchRequestInfo);
+        const aggregateRequest = createAggregateUiRequest(resourceRequest, compositeRequest);
+        return networkAdapter(aggregateRequest, resourceRequestContext).then((response) => {
+            return mergeAggregateUiResponse(response, mergeRelatedRecordsFields);
+        });
+    };
+}
+/**
+ * merge the second related list record collection into first one and return it
+ */
+function mergePageUrls(first, second) {
+    first.currentPageUrl = mergeUrl(first.currentPageUrl, second.currentPageUrl);
+    first.previousPageUrl = mergeUrl(first.previousPageUrl, second.previousPageUrl);
+    first.nextPageUrl = mergeUrl(first.nextPageUrl, second.nextPageUrl);
+}
+/**
+ * merge to paging url with different set of fields or optional fields as combined one
+ * the paging url is like
+ * /services/data/v58.0/ui-api/related-list-records/001R0000006l1xKIAQ/Contacts
+ * ?fields=Id%2CName&optionalFields=Contact.Id%2CContact.Name&pageSize=50&pageToken=0
+ * @param path1 url path and query parmeter without domain
+ * @param path2 url path and query parmeter without domain
+ *
+ * Export to unit test
+ */
+function mergeUrl(path1, path2) {
+    if (path1 === null)
+        return path2;
+    if (path2 === null)
+        return path1;
+    // new Url(...) need the path1, path2 to be prefix-ed with this fake domain
+    const domain = 'http://c.com';
+    const url1 = new URL(domain + path1);
+    const url2 = new URL(domain + path2);
+    const searchParams1 = url1.searchParams;
+    const fields = mergeFields(url1, url2, QUERY_KEY_FIELDS);
+    if (fields && searchParams1.get(QUERY_KEY_FIELDS) !== fields) {
+        searchParams1.set(QUERY_KEY_FIELDS, fields);
+    }
+    const optionalFields = mergeFields(url1, url2, QUERY_KEY_OPTIONAL_FIELDS);
+    if (optionalFields && searchParams1.get(QUERY_KEY_OPTIONAL_FIELDS) !== optionalFields) {
+        searchParams1.set(QUERY_KEY_OPTIONAL_FIELDS, optionalFields);
+    }
+    from(searchParams1.keys())
+        .sort()
+        .forEach((key) => {
+        const value = searchParams1.get(key);
+        searchParams1.delete(key);
+        searchParams1.append(key, value);
+    });
+    return url1.toString().substr(domain.length);
+}
+function mergeFields(url1, url2, name) {
+    const fields1 = ScopedFieldsCollection.fromQueryParameterValue(url1.searchParams.get(name));
+    const fields2 = ScopedFieldsCollection.fromQueryParameterValue(url2.searchParams.get(name));
+    fields1.merge(fields2);
+    return fields1.toQueryParameterValue();
+}
+/**
+ * Checks that all records ids exist in both arrays
+ * @param first batch of first array or records
+ * @param second batch of second array or records
+ * @returns
+ */
+function recordIdsAllMatch(first, second) {
+    const firstIds = first.map((record) => record.id);
+    const secondIds = second.map((record) => record.id);
+    return firstIds.every((id) => secondIds.includes(id));
 }
 
-const RELATED_LIST_RECORDS_BATCH_ENDPOINT_REGEX = /^\/ui-api\/related-list-records\/batch\/?(([a-zA-Z0-9]+))?\//;
-const referenceId = 'LDS_Related_List_Records_AggregateUi';
-function makeNetworkChunkFieldsGetRelatedListRecordsBatch(networkAdapter) {
-    return (resourceRequest, resourceRequestContext) => {
-        const batchRequestInfo = createAggregateBatchRequestInfo(resourceRequest, RELATED_LIST_RECORDS_BATCH_ENDPOINT_REGEX);
-        if (batchRequestInfo === undefined) {
-            return networkAdapter(resourceRequest, resourceRequestContext);
-        }
-        const compositeRequest = buildCompositeRequestByFields(referenceId, resourceRequest, batchRequestInfo);
-        const aggregateRequest = createAggregateUiRequest(resourceRequest, compositeRequest);
-        return networkAdapter(aggregateRequest, resourceRequestContext).then((response) => {
-            return mergeAggregateUiResponse(response, (first, second) => {
-                return mergeBatchRecordsFields(first, second, (a, b) => {
-                    return mergeRelatedRecordsFields(a, b);
-                });
-            });
-        });
-    };
+const RELATED_LIST_RECORDS_BATCH_ENDPOINT_REGEX = /^\/ui-api\/related-list-records\/batch\/?(([a-zA-Z0-9]+))?\//;
+const referenceId = 'LDS_Related_List_Records_AggregateUi';
+function makeNetworkChunkFieldsGetRelatedListRecordsBatch(networkAdapter) {
+    return (resourceRequest, resourceRequestContext) => {
+        const batchRequestInfo = createAggregateBatchRequestInfo(resourceRequest, RELATED_LIST_RECORDS_BATCH_ENDPOINT_REGEX);
+        if (batchRequestInfo === undefined) {
+            return networkAdapter(resourceRequest, resourceRequestContext);
+        }
+        const compositeRequest = buildCompositeRequestByFields(referenceId, resourceRequest, batchRequestInfo);
+        const aggregateRequest = createAggregateUiRequest(resourceRequest, compositeRequest);
+        return networkAdapter(aggregateRequest, resourceRequestContext).then((response) => {
+            return mergeAggregateUiResponse(response, (first, second) => {
+                return mergeBatchRecordsFields(first, second, (a, b) => {
+                    return mergeRelatedRecordsFields(a, b);
+                });
+            });
+        });
+    };
 }
 
-/**
- * Higher order function that accepts a network adapter and returns a new network adapter
- * that is capable of performing field batching to ensure that URL length limits are respected
- * when hitting record endpoints that accept a field list
- *
- * @param networkAdapter the network adapter to do the call.
- */
-function makeNetworkAdapterChunkRecordFields(networkAdapter) {
-    // endpoint handlers that support aggregate-ui field batching
-    const batchHandlers = [
-        makeNetworkChunkFieldsGetRecord,
-        makeNetworkChunkFieldsGetRecordsBatch,
-        makeNetworkChunkFieldsGetRelatedListRecords,
-        makeNetworkChunkFieldsGetRelatedListRecordsBatch,
-    ];
-    return batchHandlers.reduce((network, handler) => {
-        return handler(network);
-    }, networkAdapter);
+/**
+ * Higher order function that accepts a network adapter and returns a new network adapter
+ * that is capable of performing field batching to ensure that URL length limits are respected
+ * when hitting record endpoints that accept a field list
+ *
+ * @param networkAdapter the network adapter to do the call.
+ */
+function makeNetworkAdapterChunkRecordFields(networkAdapter) {
+    // endpoint handlers that support aggregate-ui field batching
+    const batchHandlers = [
+        makeNetworkChunkFieldsGetRecord,
+        makeNetworkChunkFieldsGetRecordsBatch,
+        makeNetworkChunkFieldsGetRelatedListRecords,
+        makeNetworkChunkFieldsGetRelatedListRecordsBatch,
+    ];
+    return batchHandlers.reduce((network, handler) => {
+        return handler(network);
+    }, networkAdapter);
 }
 
 export { NimbusNetworkAdapter, makeNetworkAdapterChunkRecordFields };