@salesforce/lds-network-nimbus 0.1.0-dev1

package/LICENSE.txt

@@ -0,0 +1,82 @@
+Terms of Use
+
+Copyright 2022 Salesforce, Inc. All rights reserved.
+
+These Terms of Use govern the download, installation, and/or use of this
+software provided by Salesforce, Inc. ("Salesforce") (the "Software"), were
+last updated on April 15, 2022, and constitute a legally binding
+agreement between you and Salesforce. If you do not agree to these Terms of
+Use, do not install or use the Software.
+
+Salesforce grants you a worldwide, non-exclusive, no-charge, royalty-free
+copyright license to reproduce, prepare derivative works of, publicly
+display, publicly perform, sublicense, and distribute the Software and
+derivative works subject to these Terms. These Terms shall be included in
+all copies or substantial portions of the Software.
+
+Subject to the limited rights expressly granted hereunder, Salesforce
+reserves all rights, title, and interest in and to all intellectual
+property subsisting in the Software. No rights are granted to you hereunder
+other than as expressly set forth herein. Users residing in countries on
+the United States Office of Foreign Assets Control sanction list, or which
+are otherwise subject to a US export embargo, may not use the Software.
+
+Implementation of the Software may require development work, for which you
+are responsible. The Software may contain bugs, errors and
+incompatibilities and is made available on an AS IS basis without support,
+updates, or service level commitments.
+
+Salesforce reserves the right at any time to modify, suspend, or
+discontinue, the Software (or any part thereof) with or without notice. You
+agree that Salesforce shall not be liable to you or to any third party for
+any modification, suspension, or discontinuance.
+
+You agree to defend Salesforce against any claim, demand, suit or
+proceeding made or brought against Salesforce by a third party arising out
+of or accruing from (a) your use of the Software, and (b) any application
+you develop with the Software that infringes any copyright, trademark,
+trade secret, trade dress, patent, or other intellectual property right of
+any person or defames any person or violates their rights of publicity or
+privacy (each a "Claim Against Salesforce"), and will indemnify Salesforce
+from any damages, attorney fees, and costs finally awarded against
+Salesforce as a result of, or for any amounts paid by Salesforce under a
+settlement approved by you in writing of, a Claim Against Salesforce,
+provided Salesforce (x) promptly gives you written notice of the Claim
+Against Salesforce, (y) gives you sole control of the defense and
+settlement of the Claim Against Salesforce (except that you may not settle
+any Claim Against Salesforce unless it unconditionally releases Salesforce
+of all liability), and (z) gives you all reasonable assistance, at your
+expense.
+
+WITHOUT LIMITING THE GENERALITY OF THE FOREGOING, THE SOFTWARE IS NOT
+SUPPORTED AND IS PROVIDED "AS IS," WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED. IN NO EVENT SHALL SALESFORCE HAVE ANY LIABILITY FOR ANY DAMAGES,
+INCLUDING, BUT NOT LIMITED TO, DIRECT, INDIRECT, SPECIAL, INCIDENTAL,
+PUNITIVE, OR CONSEQUENTIAL DAMAGES, OR DAMAGES BASED ON LOST PROFITS, DATA,
+OR USE, IN CONNECTION WITH THE SOFTWARE, HOWEVER CAUSED AND WHETHER IN
+CONTRACT, TORT, OR UNDER ANY OTHER THEORY OF LIABILITY, WHETHER OR NOT YOU
+HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+These Terms of Use shall be governed exclusively by the internal laws of
+the State of California, without regard to its conflicts of laws
+rules. Each party hereby consents to the exclusive jurisdiction of the
+state and federal courts located in San Francisco County, California to
+adjudicate any dispute arising out of or relating to these Terms of Use and
+the download, installation, and/or use of the Software. Except as expressly
+stated herein, these Terms of Use constitute the entire agreement between
+the parties, and supersede all prior and contemporaneous agreements,
+proposals, or representations, written or oral, concerning their subject
+matter. No modification, amendment, or waiver of any provision of these
+Terms of Use shall be effective unless it is by an update to these Terms of
+Use that Salesforce makes available, or is in writing and signed by the
+party against whom the modification, amendment, or waiver is to be
+asserted.
+
+Data Privacy: Salesforce may collect, process, and store device,
+system, and other information related to your use of the Software. This
+information includes, but is not limited to, IP address, user metrics, and
+other data ("Usage Data"). Salesforce may use Usage Data for analytics,
+product development, and marketing purposes. You acknowledge that files
+generated in conjunction with the Software may contain sensitive or
+confidential data, and you are solely responsible for anonymizing and
+protecting such data.

package/dist/main.js

@@ -0,0 +1,695 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+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 { 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;
+    }
+    if (typeof value === 'string') {
+        return value;
+    }
+    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
+/* global __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_URL_LENGTH) {
+        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;
+    }
+}
+
+//Salesforce/Akamai cdn uri max size is 8898 bytes, short than normal. Per
+//https://help.salesforce.com/s/articleView?id=sf.community_builder_cdn_considerations.htm&type=5
+//Due to we don't know the domain ResourceRequest, here we give 8000
+const MAX_URL_LENGTH = 8000;
+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) {
+    if (response.ok === false) {
+        return response;
+    }
+    const body = response.body;
+    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, maxLengthPerChunk) {
+    return fieldsArray.length + optionalFieldsArray.length >= maxLengthPerChunk;
+}
+function isSpanningRecord(fieldValue) {
+    return fieldValue !== null && typeof fieldValue === 'object' && !Array.isArray(fieldValue);
+}
+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, instrumentationSink) {
+    // only handle GETs on the given endpoint regex
+    if (!isGetRequestForEndpoint(endpoint, resourceRequest)) {
+        return undefined;
+    }
+    if (instrumentationSink) {
+        instrumentationSink.reportChunkCandidateUrlLength(calculateEstimatedTotalUrlLength(resourceRequest));
+    }
+    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 allowedMaxStringLengthPerChunk = getMaxLengthPerChunkAllowed(resourceRequest);
+    const fieldsString = fieldsArray.join(',');
+    const optionalFieldsString = optionalFieldsArray.join(',');
+    const shouldUseAggregate = shouldUseAggregateUiForFields(fieldsString, optionalFieldsString, allowedMaxStringLengthPerChunk);
+    if (!shouldUseAggregate) {
+        return undefined;
+    }
+    const fieldCollection = ScopedFieldsCollection.fromQueryParameterValue(fieldsString).split(allowedMaxStringLengthPerChunk);
+    const optionalFieldCollection = ScopedFieldsCollection.fromQueryParameterValue(optionalFieldsString).split(allowedMaxStringLengthPerChunk);
+    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 : [];
+}
+/**
+ * Calculate the max length per chunk.
+ * Max chunk size is MAX_URL_LENGTH - the url without fields and optional fields.
+ *
+ * @param resourceRequest
+ * @returns
+ */
+function getMaxLengthPerChunkAllowed(request) {
+    // Too much work to get exact length of the final url, so use stringified json to get the rough length.
+    const roughUrlLengthWithoutFieldsAndOptionFields = request.basePath.length +
+        request.baseUri.length +
+        (request.urlParams ? stringify(request.urlParams).length : 0) +
+        stringify({ ...request.queryParams, fields: {}, optionalFields: {} }).length;
+    return MAX_URL_LENGTH - roughUrlLengthWithoutFieldsAndOptionFields;
+}
+// we don't have access to the host so we cannot calculate the exact length of the url
+// so we will estimate it
+function calculateEstimatedTotalUrlLength(request) {
+    const { baseUri, basePath, queryParams } = request;
+    let url = `${baseUri}${basePath}`;
+    if (queryParams) {
+        const queryParamString = entries(queryParams)
+            .map(([key, value]) => `${key}=${value}`)
+            .join('&');
+        if (queryParamString) {
+            url += `?${queryParamString}`;
+        }
+    }
+    return url.length;
+}
+
+const RECORD_ENDPOINT_REGEX = /^\/ui-api\/records\/?(([a-zA-Z0-9]+))?$/;
+const referenceId$1 = '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, instrumentationSink) {
+    return (resourceRequest, resourceRequestContext) => {
+        const batchRequestInfo = createAggregateBatchRequestInfo(resourceRequest, RECORD_ENDPOINT_REGEX, instrumentationSink);
+        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, mergeGetRecordResult);
+        });
+    };
+}
+
+const RECORDS_BATCH_ENDPOINT_REGEX = /^\/ui-api\/records\/batch\/?(([a-zA-Z0-9|,]+))?$/;
+const referenceId = 'LDS_Records_Batch_AggregateUi';
+function makeNetworkChunkFieldsGetRecordsBatch(networkAdapter, intrumentationSink) {
+    return (resourceRequest, resourceRequestContext) => {
+        const batchRequestInfo = createAggregateBatchRequestInfo(resourceRequest, RECORDS_BATCH_ENDPOINT_REGEX, intrumentationSink);
+        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 mergeRecordFields(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, instrumentationSink) {
+    // endpoint handlers that support aggregate-ui field batching
+    const batchHandlers = [makeNetworkChunkFieldsGetRecord, makeNetworkChunkFieldsGetRecordsBatch];
+    return batchHandlers.reduce((network, handler) => {
+        return handler(network, instrumentationSink);
+    }, networkAdapter);
+}
+
+export { NimbusNetworkAdapter, makeNetworkAdapterChunkRecordFields };

package/dist/types/main.d.ts

@@ -0,0 +1,3 @@
+export { NimbusNetworkAdapter } from './network/NimbusNetworkAdapter';
+export { makeNetworkAdapterChunkRecordFields } from './network/record-field-batching/makeNetworkAdapterChunkRecordFields';
+export { CompositeResponseEnvelope } from './network/record-field-batching/utils';

package/dist/types/network/NimbusNetworkAdapter.d.ts

@@ -0,0 +1,2 @@
+import type { NetworkAdapter } from '@luvio/engine';
+export declare const NimbusNetworkAdapter: NetworkAdapter;

package/dist/types/network/__mocks__/o11y/activity.d.ts

@@ -0,0 +1,11 @@
+declare function stop(_userSchemaOrText?: any | string, _userData?: any): void;
+declare function error(_error: Error, _userSchemaOrText?: any | string, _userData?: any): void;
+declare function discard(): void;
+declare function terminate(): void;
+export declare const activity: {
+    stop: typeof stop;
+    error: typeof error;
+    discard: typeof discard;
+    terminate: typeof terminate;
+};
+export {};

package/dist/types/network/__mocks__/o11y/client.d.ts

@@ -0,0 +1,11 @@
+export { activity } from './activity';
+export { instrumentation } from './instrumentation';
+export { idleDetector } from './idleDetector';
+export declare function getInstrumentation(_name: string): {
+    log: (_schema: any, _data?: any) => void;
+    error: (_err: Error, _userSchemaOrText?: string | undefined, _data?: any) => void;
+    startActivity: (_name: string) => any;
+    incrementCounter: (_operation: string, _increment?: number | undefined, _hasError?: boolean | undefined, _tags?: any) => void;
+    trackValue: (_operation: string, _value: number, _hasError?: boolean | undefined, _tags?: any) => void;
+    bucketValue: (_operation: string, _value: number, _buckets: number[]) => void;
+};

package/dist/types/network/__mocks__/o11y/idleDetector.d.ts

@@ -0,0 +1,18 @@
+declare function requestIdleDetectedCallback(_callback: any): void;
+declare function declareNotifierTaskSingle(_name: string): {
+    isBusy: boolean;
+    done: () => void;
+};
+declare function declareNotifierTaskMulti(_name: string, _existingBusyCount?: number): {
+    isBusy: boolean;
+    add: () => void;
+    done: () => void;
+};
+declare function declarePollableTaskMulti(_name: string, _isBusyChecker: any): void;
+export declare const idleDetector: {
+    requestIdleDetectedCallback: typeof requestIdleDetectedCallback;
+    declareNotifierTaskSingle: typeof declareNotifierTaskSingle;
+    declareNotifierTaskMulti: typeof declareNotifierTaskMulti;
+    declarePollableTaskMulti: typeof declarePollableTaskMulti;
+};
+export {};

package/dist/types/network/__mocks__/o11y/instrumentation.d.ts

@@ -0,0 +1,16 @@
+declare function log(_schema: any, _data?: any): void;
+declare function error(_err: Error, _userSchemaOrText?: string, _data?: any): void;
+declare function startActivity(_name: string): any;
+declare function incrementCounter(_operation: string, _increment?: number, _hasError?: boolean, _tags?: any): void;
+declare function trackValue(_operation: string, _value: number, _hasError?: boolean, _tags?: any): void;
+declare function bucketValue(_operation: string, _value: number, _buckets: number[]): void;
+export declare const instrumentation: {
+    log: typeof log;
+    error: typeof error;
+    startActivity: typeof startActivity;
+    incrementCounter: typeof incrementCounter;
+    trackValue: typeof trackValue;
+    bucketValue: typeof bucketValue;
+};
+export declare const METRIC_KEYS: {};
+export {};

package/dist/types/network/networkUtils.d.ts

@@ -0,0 +1,4 @@
+import type { Request, Response } from '@salesforce/nimbus-plugin-lds';
+import type { ResourceRequest, FetchResponse, ResourceRequestContext } from '@luvio/engine';
+export declare function buildNimbusNetworkPluginRequest(resourceRequest: ResourceRequest, resourceRequestContext: ResourceRequestContext): Request;
+export declare function buildLdsResponse(response: Response): FetchResponse<any>;

package/dist/types/network/record-field-batching/ScopedFields.d.ts

@@ -0,0 +1,44 @@
+export declare class ScopedFields {
+    scope: string;
+    fields: Record<string, true>;
+    constructor(scope: string, fields: Array<string>);
+    isUnScoped(): boolean;
+    addField(field: string): void;
+    addFields(fields: Array<string>): void;
+    toQueryParameterValue(): string;
+    toQueryParams(): string | string[];
+    /**
+     * parse Contacts:Contact.Id,Contact.Name into a QueryFields
+     */
+    static fromQueryParameterValue(paramValue: string): ScopedFields | undefined;
+}
+export declare class ScopedFieldsCollection {
+    listIdToFieldsMap: Record<string, ScopedFields>;
+    /**
+     * merge the from ScopedFieldsCollection into current one
+     * @param from
+     */
+    merge(from: ScopedFieldsCollection): void;
+    toQueryParams(): string | string[];
+    /**
+     * convert to query parameter value
+     * @returns
+     */
+    toQueryParameterValue(): string;
+    /**
+     * split the ScopedFields into multiple ScopedFields
+     * which there max fields list length will not exceeded the specified maxLength
+     * @param maxLength
+     */
+    split(maxLength?: number): Array<ScopedFieldsCollection>;
+    size(): number;
+    countOfUnScoped(): number;
+    countOfScoped(): number;
+    isUnScopedMixedWithScoped(): boolean;
+    /**
+     *
+     * @param paramValue like Contacts:Contact.Id,Contact.Name;Opportunities:Opportunity.Id
+     * @returns
+     */
+    static fromQueryParameterValue(paramValue: String | null): ScopedFieldsCollection;
+}

package/dist/types/network/record-field-batching/makeNetworkAdapterChunkRecordFields.d.ts

@@ -0,0 +1,11 @@
+import type { NetworkAdapter } from '@luvio/engine';
+/**
+ * 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.
+ */
+export declare function makeNetworkAdapterChunkRecordFields(networkAdapter: NetworkAdapter, instrumentationSink: {
+    reportChunkCandidateUrlLength: (urlLength: number) => void;
+}): NetworkAdapter;

package/dist/types/network/record-field-batching/makeNetworkChunkFieldsGetRecord.d.ts

@@ -0,0 +1,15 @@
+import type { NetworkAdapter, FetchResponse } from '@luvio/engine';
+import type { RecordRepresentation } from '@salesforce/lds-adapters-uiapi';
+import type { AggregateResponse, InstrumentationSink, UiApiErrorResponse } from './utils';
+export type GetRecordResult = RecordRepresentation | UiApiErrorResponse;
+export type GetRecordAggregateResponse = AggregateResponse<GetRecordResult>;
+export type GetRecordResponse = FetchResponse<GetRecordResult>;
+/**
+ * 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
+ */
+export declare function mergeGetRecordResult(first: GetRecordResult, second: GetRecordResult): GetRecordResult;
+export declare function makeNetworkChunkFieldsGetRecord(networkAdapter: NetworkAdapter, instrumentationSink: InstrumentationSink): NetworkAdapter;

package/dist/types/network/record-field-batching/makeNetworkChunkFieldsGetRecordsBatch.d.ts

@@ -0,0 +1,7 @@
+import type { FetchResponse, NetworkAdapter } from '@luvio/engine';
+import type { BatchRepresentation } from '@salesforce/lds-adapters-uiapi';
+import type { AggregateResponse, InstrumentationSink } from './utils';
+export declare const RECORDS_BATCH_ENDPOINT_REGEX: RegExp;
+export type GetRecordsBatchAggregateResponse = AggregateResponse<BatchRepresentation>;
+export type GetRecordsBatchResponse = FetchResponse<BatchRepresentation>;
+export declare function makeNetworkChunkFieldsGetRecordsBatch(networkAdapter: NetworkAdapter, intrumentationSink: InstrumentationSink): NetworkAdapter;

package/dist/types/network/record-field-batching/utils.d.ts

@@ -0,0 +1,74 @@
+import type { ResourceRequest, FetchResponse } from '@luvio/engine';
+import { HttpStatusCode } from '@luvio/engine';
+import type { RecordRepresentation, BatchRepresentation, RelatedListRecordCollectionRepresentation, RelatedListRecordCollectionBatchRepresentation } from '@salesforce/lds-adapters-uiapi';
+import type { GetRecordResult } from './makeNetworkChunkFieldsGetRecord';
+import { ScopedFieldsCollection } from './ScopedFields';
+export declare const MAX_URL_LENGTH = 8000;
+export interface CompositeRequest {
+    url: string;
+    referenceId: string;
+}
+interface UiApiClientOptions {
+    ifModifiedSince?: string;
+    ifUnmodifiedSince?: string;
+}
+export interface UiApiParams {
+    [name: string]: any;
+    clientOptions?: UiApiClientOptions;
+}
+export interface UiApiError {
+    errorCode: string;
+    message: string;
+}
+export type UiApiErrorResponse = Array<UiApiError>;
+export type CompositeResponse<T> = {
+    body: T;
+    httpStatusCode: HttpStatusCode;
+};
+export interface CompositeResponseEnvelope<T> {
+    compositeResponse: CompositeResponse<T | UiApiErrorResponse>[];
+}
+/**
+ * Object Representation types allowed when merging
+ */
+type SupportedAggregateRepresentation<T> = Extract<T, GetRecordResult | BatchRepresentation | RelatedListRecordCollectionRepresentation | RelatedListRecordCollectionBatchRepresentation>;
+export type AggregateResponse<T> = FetchResponse<CompositeResponseEnvelope<SupportedAggregateRepresentation<T>> | UiApiErrorResponse>;
+/**
+ * Supported batch representation
+ */
+type SupportedBatchRepresentation = RelatedListRecordCollectionBatchRepresentation | BatchRepresentation;
+/**
+ * Supported batch representation
+ */
+type SupportedBatchCollectionRepresentation = RelatedListRecordCollectionRepresentation | RecordRepresentation;
+export interface InstrumentationSink {
+    reportChunkCandidateUrlLength: (urlLength: number) => void;
+}
+/**
+ * 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
+ */
+export declare function mergeAggregateUiResponse<T>(response: AggregateResponse<T>, mergeFunc: (first: T, second: T) => SupportedAggregateRepresentation<T>): FetchResponse<SupportedAggregateRepresentation<T> | UiApiErrorResponse>;
+export declare function buildAggregateUiUrl(params: UiApiParams, resourceRequest: ResourceRequest): string;
+export declare function shouldUseAggregateUiForFields(fieldsArray: string, optionalFieldsArray: string, maxLengthPerChunk: number): boolean;
+export declare function isSpanningRecord(fieldValue: null | string | string[] | number | boolean | RecordRepresentation): fieldValue is RecordRepresentation;
+export declare function mergeRecordFields(first: RecordRepresentation, second: RecordRepresentation): RecordRepresentation;
+export declare function mergeBatchRecordsFields(first: SupportedBatchRepresentation, second: SupportedBatchRepresentation, collectionMergeFunc: (first: SupportedBatchCollectionRepresentation, second: SupportedBatchCollectionRepresentation) => SupportedBatchCollectionRepresentation): SupportedBatchRepresentation;
+/**
+ * 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.
+ */
+export declare function createAggregateBatchRequestInfo(resourceRequest: ResourceRequest, endpoint: RegExp, instrumentationSink?: InstrumentationSink): {
+    fieldCollection: ScopedFieldsCollection[];
+    optionalFieldCollection: ScopedFieldsCollection[];
+} | undefined;
+export declare function createAggregateUiRequest(resourceRequest: ResourceRequest, compositeRequest: CompositeRequest[]): ResourceRequest;
+export declare function buildCompositeRequestByFields(referenceId: string, resourceRequest: ResourceRequest, recordsCompositeRequest: {
+    fieldCollection: ScopedFieldsCollection[] | undefined;
+    optionalFieldCollection: ScopedFieldsCollection[] | undefined;
+}): CompositeRequest[];
+export {};

package/dist/types/utils/language.d.ts

@@ -0,0 +1,29 @@
+declare const keys: {
+    (o: object): string[];
+    (o: {}): string[];
+}, create: {
+    (o: object | null): any;
+    (o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
+}, assign: {
+    <T extends {}, U>(target: T, source: U): T & U;
+    <T_1 extends {}, U_1, V>(target: T_1, source1: U_1, source2: V): T_1 & U_1 & V;
+    <T_2 extends {}, U_2, V_1, W>(target: T_2, source1: U_2, source2: V_1, source3: W): T_2 & U_2 & V_1 & W;
+    (target: object, ...sources: any[]): any;
+}, entries: {
+    <T>(o: {
+        [s: string]: T;
+    } | ArrayLike<T>): [string, T][];
+    (o: {}): [string, any][];
+};
+declare const stringify: {
+    (value: any, replacer?: ((this: any, key: string, value: any) => any) | undefined, space?: string | number | undefined): string;
+    (value: any, replacer?: (string | number)[] | null | undefined, space?: string | number | undefined): string;
+}, parse: (text: string, reviver?: ((this: any, key: string, value: any) => any) | undefined) => any;
+declare const push: (...items: any[]) => number, join: (separator?: string | undefined) => string, slice: (start?: number | undefined, end?: number | undefined) => any[];
+declare const isArray: (arg: any) => arg is any[], from: {
+    <T>(arrayLike: ArrayLike<T>): T[];
+    <T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+    <T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+    <T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+};
+export { keys as ObjectKeys, create as ObjectCreate, assign as ObjectAssign, entries as ObjectEntries, push as ArrayPrototypePush, join as ArrayPrototypeJoin, slice as ArrayPrototypeSlice, isArray as ArrayIsArray, from as ArrayFrom, stringify as JSONStringify, parse as JSONParse, };

package/package.json

@@ -0,0 +1,49 @@
+{
+    "name": "@salesforce/lds-network-nimbus",
+    "version": "0.1.0-dev1",
+    "license": "SEE LICENSE IN LICENSE.txt",
+    "description": "A nimbus-plugin-based implementation of the Luvio NetworkAdapter.",
+    "main": "dist/main.js",
+    "module": "dist/main.js",
+    "types": "dist/types/main.d.ts",
+    "files": [
+        "dist"
+    ],
+    "exports": {
+        ".": {
+            "types": "./dist/types/main.d.ts",
+            "import": "./dist/main.js",
+            "default": "./dist/main.js"
+        }
+    },
+    "scripts": {
+        "prepare": "yarn build",
+        "build": "rollup --bundleConfigAsCjs --config rollup.config.js",
+        "test:debug": "node --inspect-brk ../../node_modules/.bin/jest --runInBand",
+        "test:unit": "NODE_ENV=production jest",
+        "test:size": "luvioBundlesize",
+        "clean": "rm -rf dist"
+    },
+    "dependencies": {
+        "@luvio/engine": "0.158.7",
+        "@salesforce/lds-instrumentation": "^0.1.0-dev1",
+        "o11y": "250.7.0"
+    },
+    "devDependencies": {
+        "@salesforce/lds-adapters-uiapi": "^0.1.0-dev1",
+        "@salesforce/nimbus-plugin-lds": "^0.1.0-dev1"
+    },
+    "luvioBundlesize": [
+        {
+            "path": "./dist/main.js",
+            "maxSize": {
+                "none": "33 kB",
+                "min": "13 kB",
+                "compressed": "7 kB"
+            }
+        }
+    ],
+    "volta": {
+        "extends": "../../package.json"
+    }
+}