@salesforce/lds-network-fetch 1.332.0

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/ldsNetworkFetch.js

@@ -0,0 +1,810 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/*
+ *  ATTENTION!
+ *  THIS IS A GENERATED FILE FROM https://github.com/salesforce-experience-platform-emu/lds-lightning-platform
+ *  If you would like to contribute to LDS, please follow the steps outlined in the git repo.
+ *  Any changes made to this file in p4 will be automatically overwritten.
+ *  *******************************************************************************************
+ */
+/* proxy-compat-disable */
+import { UIAPI_GET_LAYOUT, UIAPI_GET_LAYOUT_USER_STATE, UIAPI_OBJECT_INFO_BATCH_PATH, UIAPI_OBJECT_INFO_PATH, shouldForceRefresh, createOkResponse as createOkResponse$1, layoutUserStateStorage, layoutUserStateStorageStatsLogger, layoutStorage, layoutStorageStatsLogger, objectInfoStorage, objectInfoStorageStatsLogger, getTransactionKey as getTransactionKey$1 } from 'force/ldsNetwork';
+import { HttpStatusCode as HttpStatusCode$1 } from 'force/luvioEngine';
+
+var SnapshotState;
+(function (SnapshotState) {
+    SnapshotState["Fulfilled"] = "Fulfilled";
+    SnapshotState["Unfulfilled"] = "Unfulfilled";
+    SnapshotState["Error"] = "Error";
+    SnapshotState["Pending"] = "Pending";
+    SnapshotState["Stale"] = "Stale";
+})(SnapshotState || (SnapshotState = {}));
+const { isArray: isArray$1 } = Array;
+
+Promise.resolve();
+
+var StoreErrorStatus;
+(function (StoreErrorStatus) {
+    StoreErrorStatus[StoreErrorStatus["RESOURCE_NOT_FOUND"] = 404] = "RESOURCE_NOT_FOUND";
+})(StoreErrorStatus || (StoreErrorStatus = {}));
+var StoreRecordType;
+(function (StoreRecordType) {
+    StoreRecordType["Error"] = "error";
+})(StoreRecordType || (StoreRecordType = {}));
+var StoreLinkStateValues$1;
+(function (StoreLinkStateValues) {
+    StoreLinkStateValues[StoreLinkStateValues["NotPresent"] = 0] = "NotPresent";
+    StoreLinkStateValues[StoreLinkStateValues["RefNotPresent"] = 1] = "RefNotPresent";
+    StoreLinkStateValues[StoreLinkStateValues["RefPresent"] = 2] = "RefPresent";
+    StoreLinkStateValues[StoreLinkStateValues["Null"] = 3] = "Null";
+    StoreLinkStateValues[StoreLinkStateValues["Missing"] = 4] = "Missing";
+    StoreLinkStateValues[StoreLinkStateValues["Pending"] = 5] = "Pending";
+})(StoreLinkStateValues$1 || (StoreLinkStateValues$1 = {}));
+var StoreResolveResultState;
+(function (StoreResolveResultState) {
+    StoreResolveResultState[StoreResolveResultState["Found"] = 0] = "Found";
+    StoreResolveResultState[StoreResolveResultState["Error"] = 1] = "Error";
+    StoreResolveResultState[StoreResolveResultState["Null"] = 2] = "Null";
+    StoreResolveResultState[StoreResolveResultState["NotPresent"] = 3] = "NotPresent";
+    StoreResolveResultState[StoreResolveResultState["Stale"] = 4] = "Stale";
+})(StoreResolveResultState || (StoreResolveResultState = {}));
+var HttpStatusCode;
+(function (HttpStatusCode) {
+    HttpStatusCode[HttpStatusCode["Ok"] = 200] = "Ok";
+    HttpStatusCode[HttpStatusCode["Created"] = 201] = "Created";
+    HttpStatusCode[HttpStatusCode["NoContent"] = 204] = "NoContent";
+    HttpStatusCode[HttpStatusCode["NotModified"] = 304] = "NotModified";
+    HttpStatusCode[HttpStatusCode["BadRequest"] = 400] = "BadRequest";
+    HttpStatusCode[HttpStatusCode["Unauthorized"] = 401] = "Unauthorized";
+    HttpStatusCode[HttpStatusCode["Forbidden"] = 403] = "Forbidden";
+    HttpStatusCode[HttpStatusCode["NotFound"] = 404] = "NotFound";
+    HttpStatusCode[HttpStatusCode["ServerError"] = 500] = "ServerError";
+    HttpStatusCode[HttpStatusCode["GatewayTimeout"] = 504] = "GatewayTimeout";
+})(HttpStatusCode || (HttpStatusCode = {}));
+/**
+ * A type guard function for determining if an unknown object is a {@link FormData}
+ */
+function isFormData(obj) {
+    return (typeof obj === 'object' &&
+        obj !== null &&
+        'namedEntries' in obj &&
+        isArray$1(obj.namedEntries));
+}
+/**
+ * A type guard function for determining if an unknown object is a {@link FileReference}
+ */
+function isFileReference(entryValue) {
+    return (typeof entryValue === 'object' &&
+        entryValue !== null &&
+        'isFileReference' in entryValue &&
+        entryValue.isFileReference === true);
+}
+var GraphNodeType;
+(function (GraphNodeType) {
+    GraphNodeType["Link"] = "Link";
+    GraphNodeType["Node"] = "Node";
+    GraphNodeType["Error"] = "Error";
+    GraphNodeType["Locked"] = "Locked";
+})(GraphNodeType || (GraphNodeType = {}));
+
+var StoreLinkStateValues;
+(function (StoreLinkStateValues) {
+    StoreLinkStateValues[StoreLinkStateValues["NotPresent"] = 0] = "NotPresent";
+    StoreLinkStateValues[StoreLinkStateValues["RefNotPresent"] = 1] = "RefNotPresent";
+    StoreLinkStateValues[StoreLinkStateValues["RefPresent"] = 2] = "RefPresent";
+    StoreLinkStateValues[StoreLinkStateValues["Null"] = 3] = "Null";
+    StoreLinkStateValues[StoreLinkStateValues["Missing"] = 4] = "Missing";
+    StoreLinkStateValues[StoreLinkStateValues["Pending"] = 5] = "Pending";
+})(StoreLinkStateValues || (StoreLinkStateValues = {}));
+var FragmentReadResultState;
+(function (FragmentReadResultState) {
+    FragmentReadResultState[FragmentReadResultState["Missing"] = 0] = "Missing";
+    FragmentReadResultState[FragmentReadResultState["Success"] = 1] = "Success";
+    FragmentReadResultState[FragmentReadResultState["Error"] = 2] = "Error";
+})(FragmentReadResultState || (FragmentReadResultState = {}));
+({
+    state: FragmentReadResultState.Missing,
+});
+
+var ResourceParamType;
+(function (ResourceParamType) {
+    ResourceParamType[ResourceParamType["UrlParameter"] = 0] = "UrlParameter";
+    ResourceParamType[ResourceParamType["QueryParameter"] = 1] = "QueryParameter";
+    ResourceParamType[ResourceParamType["Body"] = 2] = "Body";
+    ResourceParamType[ResourceParamType["Header"] = 3] = "Header";
+})(ResourceParamType || (ResourceParamType = {}));
+var TypeCheckShapes;
+(function (TypeCheckShapes) {
+    TypeCheckShapes[TypeCheckShapes["String"] = 0] = "String";
+    TypeCheckShapes[TypeCheckShapes["Boolean"] = 1] = "Boolean";
+    TypeCheckShapes[TypeCheckShapes["Number"] = 2] = "Number";
+    TypeCheckShapes[TypeCheckShapes["Integer"] = 3] = "Integer";
+    TypeCheckShapes[TypeCheckShapes["Unsupported"] = 4] = "Unsupported";
+})(TypeCheckShapes || (TypeCheckShapes = {}));
+// engine version: 0.156.5-f5fd8c7a
+
+const { keys: keys$1 } = Object;
+
+// we're going to intentionally bundle this small bit of luvio engine code into
+// this module to keep it runtime dependency-free
+const fetchNetworkAdapter = async (resourceRequest, _resourceRequestContext) => {
+    const { baseUri, basePath, body: requestBody, queryParams, method, headers } = resourceRequest;
+    const qs = generateQueryString(queryParams);
+    const path = `${baseUri}${basePath}${qs}`;
+    let body;
+    // some endpoints use FormData for POST request body, check here
+    // if we have a POST body that is FormData
+    if (method === 'post' && isFormData(requestBody)) {
+        // we will populate a DOM FormData and pass that to fetch
+        const newForm = new FormData();
+        for (const { name, value } of requestBody.namedEntries) {
+            // if this is a string or real DOM File then we can
+            // just add it to FormData
+            if (typeof value === 'string' || value instanceof File) {
+                newForm.append(name, value);
+            }
+            // this network adapter doesn't currently support FileReference's
+            else if (isFileReference(value)) {
+                throw Error(`Luvio fetchNetworkAdapter does not support FileReference's`);
+            }
+            // else we have a Luvio File that isn't a real DOM file,
+            // so we need to turn it into a DOM file
+            else {
+                const buffer = await value.arrayBuffer();
+                newForm.append(name, new File([new Uint8Array(buffer)], value.name, {
+                    type: value.type,
+                }));
+            }
+        }
+        body = newForm;
+    }
+    else if (requestBody === null) {
+        body = null;
+    }
+    else {
+        body = JSON.stringify(requestBody);
+        headers['Content-Type'] = 'application/json';
+    }
+    const response = await fetch(path, {
+        method: method.toUpperCase(),
+        headers: generateHeaders(headers),
+        body,
+    });
+    const { status, ok, statusText } = response;
+    // coerce headers
+    const responseHeaders = {};
+    response.headers.forEach((value, key) => {
+        responseHeaders[key] = value;
+    });
+    // parse body
+    let responseBody = null;
+    if (status !== 204) {
+        const contentType = responseHeaders['content-type'];
+        responseBody =
+            contentType && contentType.startsWith('application/json')
+                ? await response.json()
+                : await response.text();
+    }
+    return {
+        body: responseBody,
+        status,
+        statusText,
+        ok,
+        headers: responseHeaders,
+    };
+};
+function generateQueryString(params) {
+    const queryStrings = [];
+    for (const key of keys$1(params)) {
+        queryStrings.push(`${key}=${params[key]}`);
+    }
+    if (queryStrings.length > 0) {
+        return `?${queryStrings.join('&')}`;
+    }
+    return '';
+}
+function generateHeaders(headers) {
+    const fetchHeaders = new Headers();
+    for (const key of keys$1(headers)) {
+        fetchHeaders.set(key, headers[key]);
+    }
+    return fetchHeaders;
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+const { parse, stringify } = JSON;
+const { join, push, unshift } = Array.prototype;
+const { isArray } = Array;
+const { entries, keys } = Object;
+
+const UI_API_BASE_URI = '/services/data/v63.0/ui-api';
+
+const LDS_RECORDS_AGGREGATE_UI = 'LDS_Records_AggregateUi';
+// Boundary which represents the limit that we start chunking at,
+// determined by comma separated string length of fields
+const MAX_STRING_LENGTH_PER_CHUNK = 10000;
+// UIAPI limit
+const MAX_AGGREGATE_UI_CHUNK_LIMIT = 50;
+function createOkResponse(body) {
+    return {
+        status: HttpStatusCode$1.Ok,
+        body,
+        statusText: 'ok',
+        headers: {},
+        ok: true,
+    };
+}
+function getErrorResponseText(status) {
+    switch (status) {
+        case HttpStatusCode$1.Ok:
+            return 'OK';
+        case HttpStatusCode$1.NotModified:
+            return 'Not Modified';
+        case HttpStatusCode$1.NotFound:
+            return 'Not Found';
+        case HttpStatusCode$1.BadRequest:
+            return 'Bad Request';
+        case HttpStatusCode$1.ServerError:
+            return 'Server Error';
+        default:
+            return `Unexpected HTTP Status Code: ${status}`;
+    }
+}
+function createErrorResponse(status, body) {
+    return {
+        status,
+        body,
+        statusText: getErrorResponseText(status),
+        headers: {},
+        ok: false,
+    };
+}
+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] = sourceFields[fieldName];
+                continue;
+            }
+            mergeRecordFields(targetField.value, sourceField.value);
+            continue;
+        }
+        targetFields[fieldName] = sourceFields[fieldName];
+    }
+    return first;
+}
+/** Invoke executeAggregateUi Aura controller.  This is only to be used with large getRecord requests that
+ *  would otherwise cause a query length exception.
+ */
+function dispatchSplitRecordAggregateUiAction(recordId, networkAdapter, resourceRequest, resourceRequestContext) {
+    return networkAdapter(resourceRequest, resourceRequestContext).then((resp) => {
+        const { body } = resp;
+        // This response body could be an executeAggregateUi, which we don't natively support.
+        // Massage it into looking like a getRecord response.
+        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?
+            throw createErrorResponse(HttpStatusCode$1.ServerError, {
+                error: 'No response body in executeAggregateUi found',
+            });
+        }
+        const merged = body.compositeResponse.reduce((seed, response) => {
+            if (response.httpStatusCode !== HttpStatusCode$1.Ok) {
+                throw createErrorResponse(HttpStatusCode$1.ServerError, {
+                    error: response.message,
+                });
+            }
+            if (seed === null) {
+                return response.body;
+            }
+            return mergeRecordFields(seed, response.body);
+        }, null);
+        return createOkResponse(merged);
+    }, (err) => {
+        // rethrow error
+        throw err;
+    });
+}
+function shouldUseAggregateUiForGetRecord(fieldsArray, optionalFieldsArray) {
+    return fieldsArray.length + optionalFieldsArray.length >= MAX_STRING_LENGTH_PER_CHUNK;
+}
+function buildAggregateUiUrl(params, resourceRequest) {
+    const { fields, optionalFields } = params;
+    const queryString = [];
+    if (fields !== undefined && fields.length > 0) {
+        const fieldString = join.call(fields, ',');
+        push.call(queryString, `fields=${encodeURIComponent(fieldString)}`);
+    }
+    if (optionalFields !== undefined && optionalFields.length > 0) {
+        const optionalFieldString = join.call(optionalFields, ',');
+        push.call(queryString, `optionalFields=${encodeURIComponent(optionalFieldString)}`);
+    }
+    return `${resourceRequest.baseUri}${resourceRequest.basePath}?${join.call(queryString, '&')}`;
+}
+function buildGetRecordByFieldsCompositeRequest(resourceRequest, recordsCompositeRequest) {
+    const { fieldsArray, optionalFieldsArray, fieldsLength, optionalFieldsLength } = recordsCompositeRequest;
+    // Formula:  # of fields per chunk = floor(avg field length / max length per chunk)
+    const averageFieldStringLength = Math.floor((fieldsLength + optionalFieldsLength) / (fieldsArray.length + optionalFieldsArray.length));
+    const fieldsPerChunk = Math.floor(MAX_STRING_LENGTH_PER_CHUNK / averageFieldStringLength);
+    const optionalFieldsChunks = [];
+    // Do the same for optional tracked fields
+    for (let i = 0, j = optionalFieldsArray.length; i < j; i += fieldsPerChunk) {
+        const newChunk = optionalFieldsArray.slice(i, i + fieldsPerChunk);
+        push.call(optionalFieldsChunks, newChunk);
+    }
+    const compositeRequest = [];
+    // Add fields as one chunk at the beginning of the compositeRequest
+    if (fieldsArray.length > 0) {
+        const url = buildAggregateUiUrl({
+            fields: fieldsArray,
+        }, resourceRequest);
+        push.call(compositeRequest, {
+            url,
+            referenceId: `${LDS_RECORDS_AGGREGATE_UI}_fields`,
+        });
+    }
+    // Make sure we don't exceed the max subquery chunk limit for aggUi by capping the amount
+    // of optionalFields subqueries at MAX_AGGREGATE_UI_CHUNK_LIMIT - 1 (first chunk is for fields)
+    const maxNumberOfAllowableOptionalFieldsChunks = MAX_AGGREGATE_UI_CHUNK_LIMIT - 1;
+    const optionalFieldsChunksLength = Math.min(optionalFieldsChunks.length, maxNumberOfAllowableOptionalFieldsChunks);
+    for (let i = 0; i < optionalFieldsChunksLength; i += 1) {
+        const fieldChunk = optionalFieldsChunks[i];
+        const url = buildAggregateUiUrl({
+            optionalFields: fieldChunk,
+        }, resourceRequest);
+        push.call(compositeRequest, {
+            url,
+            referenceId: `${LDS_RECORDS_AGGREGATE_UI}_optionalFields_${i}`,
+        });
+    }
+    return compositeRequest;
+}
+
+const UIAPI_RECORDS_PATH = `${UI_API_BASE_URI}/records`;
+const UIAPI_RECORDS_BATCH_PATH = `${UI_API_BASE_URI}/records/batch/`;
+const QUERY_TOO_COMPLICATED_ERROR_CODE = 'QUERY_TOO_COMPLICATED';
+function fetchResponseIsQueryTooComplicated(error) {
+    const { body } = error;
+    if (error.status === HttpStatusCode$1.BadRequest && body !== undefined) {
+        return (body.statusCode === HttpStatusCode$1.BadRequest &&
+            body.errorCode === QUERY_TOO_COMPLICATED_ERROR_CODE);
+    }
+    return false;
+}
+/*
+ * Takes a ResourceRequest, builds the aggregateUi payload, and dispatches via aggregateUi action
+ */
+function buildAndDispatchGetRecordAggregateUi(recordId, req, params) {
+    const { networkAdapter, resourceRequest, resourceRequestContext } = req;
+    const compositeRequest = buildGetRecordByFieldsCompositeRequest(resourceRequest, params);
+    const aggregateUiParams = {
+        compositeRequest,
+    };
+    const aggregateUiResourceRequest = {
+        baseUri: UI_API_BASE_URI,
+        basePath: '/aggregate-ui',
+        method: 'post',
+        priority: resourceRequest.priority,
+        urlParams: {},
+        body: aggregateUiParams,
+        queryParams: {},
+        headers: {},
+    };
+    return dispatchSplitRecordAggregateUiAction(recordId, networkAdapter, aggregateUiResourceRequest, resourceRequestContext);
+}
+const getRecordDispatcher = (req) => {
+    const { resourceRequest, networkAdapter, resourceRequestContext } = req;
+    const { queryParams, urlParams } = resourceRequest;
+    const { fields, optionalFields } = queryParams;
+    if (process.env.NODE_ENV !== 'production') {
+        if (typeof urlParams.recordId !== 'string') {
+            throw new Error(`Invalid recordId: expected string, recieved "${typeof urlParams.recordId}"`);
+        }
+    }
+    const recordId = urlParams.recordId;
+    const fieldsArray = fields !== undefined && isArray(fields) ? fields : [];
+    const optionalFieldsArray = optionalFields !== undefined && Array.isArray(optionalFields)
+        ? optionalFields
+        : [];
+    const fieldsString = fieldsArray.join(',');
+    const optionalFieldsString = optionalFieldsArray.join(',');
+    // Don't submit a megarequest to UIAPI due to SOQL limit reasons.
+    // Split and aggregate if needed
+    const useAggregateUi = shouldUseAggregateUiForGetRecord(fieldsString, optionalFieldsString);
+    if (useAggregateUi) {
+        return buildAndDispatchGetRecordAggregateUi(recordId, {
+            networkAdapter,
+            resourceRequest,
+            resourceRequestContext,
+        }, {
+            fieldsArray,
+            optionalFieldsArray,
+            fieldsLength: fieldsString.length,
+            optionalFieldsLength: optionalFieldsString.length,
+        });
+    }
+    return defaultDispatcher(req).catch((err) => {
+        if (fetchResponseIsQueryTooComplicated(err)) {
+            // Retry with aggregateUi to see if we can avoid Query Too Complicated
+            return buildAndDispatchGetRecordAggregateUi(recordId, {
+                networkAdapter,
+                resourceRequest,
+                resourceRequestContext,
+            }, {
+                fieldsArray,
+                optionalFieldsArray,
+                fieldsLength: fieldsString.length,
+                optionalFieldsLength: optionalFieldsString.length,
+            });
+        }
+        else {
+            throw err;
+        }
+    });
+};
+function matchRecordsHandlers(path, resourceRequest) {
+    const method = resourceRequest.method.toLowerCase();
+    if (method === 'get' &&
+        path.startsWith(UIAPI_RECORDS_PATH) &&
+        path.startsWith(UIAPI_RECORDS_BATCH_PATH) === false) {
+        return getRecordDispatcher;
+    }
+    return null;
+}
+
+const defaultDispatcher = (req) => {
+    const { networkAdapter, resourceRequest, resourceRequestContext } = req;
+    return networkAdapter(resourceRequest, resourceRequestContext);
+};
+function getDispatcher(resourceRequest) {
+    const { basePath, baseUri } = resourceRequest;
+    const path = `${baseUri}${basePath}`;
+    const recordsMatch = matchRecordsHandlers(path, resourceRequest);
+    if (recordsMatch !== null) {
+        return recordsMatch;
+    }
+    return defaultDispatcher;
+}
+
+const inflightRequests = Object.create(null);
+const TRANSACTION_KEY_SEP = '::';
+const EMPTY_STRING = '';
+function isResourceRequestDedupable(resourceRequest) {
+    const resourceRequestContext = resourceRequest.resourceRequestContext;
+    return (resourceRequest.resourceRequest.method.toLowerCase() === 'get' ||
+        (resourceRequestContext && resourceRequestContext.luvioRequestMethod === 'get'));
+}
+function getTransactionKey(req) {
+    const { resourceRequest } = req;
+    const { baseUri, basePath, queryParams, headers } = resourceRequest;
+    const path = `${baseUri}${basePath}`;
+    const queryParamsString = queryParams ? stringify(queryParams) : EMPTY_STRING;
+    const headersString = stringify(headers);
+    const bodyString = resourceRequest.body && isResourceRequestDedupable(req)
+        ? stringify(resourceRequest.body)
+        : EMPTY_STRING;
+    return `${path}${TRANSACTION_KEY_SEP}${headersString}${TRANSACTION_KEY_SEP}${queryParamsString}${bodyString}`;
+}
+function getFulfillingRequest(inflightRequests, resourceRequest) {
+    const { fulfill } = resourceRequest;
+    if (fulfill === undefined) {
+        return null;
+    }
+    const handlersMap = entries(inflightRequests);
+    for (let i = 0, len = handlersMap.length; i < len; i += 1) {
+        const [transactionKey, handlers] = handlersMap[i];
+        // check fulfillment against only the first handler ([0]) because it's equal or
+        // fulfills all subsequent handlers in the array
+        const existing = handlers[0].resourceRequest;
+        if (fulfill(existing, resourceRequest) === true) {
+            return transactionKey;
+        }
+    }
+    return null;
+}
+/**
+  Dedupes network requests being made to Salesforce APIs
+  This function is only designed to dedupe GET requests.
+
+  If POST/PUT/PATCH/DELETE requests need to be deduped, that should be handled
+  on the server instead of here.
+*/
+const dedupeRequest = (req) => {
+    const { resourceRequest } = req;
+    if (process.env.NODE_ENV !== 'production') {
+        if (!isResourceRequestDedupable(req)) {
+            throw new Error('Invalid ResourceRequest that cannot be deduped. Only "get" Requests supported.');
+        }
+    }
+    const transactionKey = getTransactionKey(req);
+    // if an identical request is in-flight then queue for its response (do not re-issue the request)
+    if (transactionKey in inflightRequests) {
+        return new Promise((resolve, reject) => {
+            push.call(inflightRequests[transactionKey], {
+                resolve,
+                reject,
+                resourceRequest,
+            });
+        });
+    }
+    const dispatch = getDispatcher(resourceRequest);
+    // fallback to checking a custom deduper to find a similar (but not identical) request
+    const similarTransactionKey = getFulfillingRequest(inflightRequests, resourceRequest);
+    if (similarTransactionKey !== null) {
+        return new Promise((resolve) => {
+            // custom dedupers find similar (not identical) requests. if the similar request fails
+            // there's no guarantee the deduped request should fail. thus we re-issue the
+            // original request in the case of a failure
+            push.call(inflightRequests[similarTransactionKey], {
+                resolve,
+                reject: function reissueRequest() {
+                    resolve(dispatch(req));
+                },
+                resourceRequest,
+            });
+        });
+    }
+    dispatch(req).then((response) => {
+        const handlers = inflightRequests[transactionKey];
+        delete inflightRequests[transactionKey];
+        // handlers mutate responses so must clone the response for each.
+        // the first handler is given the original version to avoid an
+        // extra clone (particularly when there's only 1 handler).
+        for (let i = 1, len = handlers.length; i < len; i++) {
+            const handler = handlers[i];
+            handler.resolve(parse(stringify(response)));
+        }
+        handlers[0].resolve(response);
+    }, (error) => {
+        const handlers = inflightRequests[transactionKey];
+        delete inflightRequests[transactionKey];
+        for (let i = 0, len = handlers.length; i < len; i++) {
+            const handler = handlers[i];
+            handler.reject(error);
+        }
+    });
+    // rely on sync behavior of Promise creation to create the list for handlers
+    return new Promise((resolve, reject) => {
+        inflightRequests[transactionKey] = [{ resolve, reject, resourceRequest }];
+    });
+};
+
+const RATE_LIMIT_CONFIG = {
+    bucketCapacity: 100,
+    fillsPerSecond: 100,
+};
+class TokenBucket {
+    /**
+     * Constructs an instance of Token Bucket for rate limiting
+     *
+     * @param bucket The token holding capacity of the bucket
+     * @param refillTokensPerSecond The number of tokens replenished every second
+     */
+    constructor(config) {
+        this.bucketCapacity = config.bucketCapacity;
+        this.refillTokensPerMilliSecond = config.fillsPerSecond / 1000;
+        this.tokens = config.bucketCapacity;
+        this.lastRefillTime = Date.now();
+    }
+    /**
+     * Refills the bucket and removes desired number of tokens
+     *
+     * @param removeTokens number of tokens to be removed from the bucket should be >= 0
+     * @returns {boolean} true if removing token was succesful
+     */
+    take(removeTokens) {
+        // refill tokens before removing
+        this.refill();
+        const { tokens } = this;
+        const remainingTokens = tokens - removeTokens;
+        if (remainingTokens >= 0) {
+            this.tokens = remainingTokens;
+            return true;
+        }
+        return false;
+    }
+    refill() {
+        const { bucketCapacity, tokens, refillTokensPerMilliSecond, lastRefillTime } = this;
+        const now = Date.now();
+        const timePassed = now - lastRefillTime;
+        // Number of tokens should be integer so something like Math.floor is desired
+        // Using Bitwise NOT ~ twice will achieve the same result with performance benefits
+        const calculatedTokens = tokens + ~~(timePassed * refillTokensPerMilliSecond);
+        this.tokens = bucketCapacity < calculatedTokens ? bucketCapacity : calculatedTokens;
+        this.lastRefillTime = now;
+    }
+}
+var tokenBucket = new TokenBucket(RATE_LIMIT_CONFIG);
+
+function platformNetworkAdapter(baseNetworkAdapter) {
+    return (resourceRequest, resourceRequestContext) => {
+        if (!tokenBucket.take(1)) ;
+        const salesforceRequest = {
+            networkAdapter: baseNetworkAdapter,
+            resourceRequest: resourceRequest,
+            resourceRequestContext: resourceRequestContext,
+        };
+        // If GET, or overriden to be treated as a GET with resourceRequestContext.networkResourceOverride, then dedupe.
+        if (isResourceRequestDedupable(salesforceRequest)) {
+            return dedupeRequest(salesforceRequest);
+        }
+        else {
+            const dispatch = getDispatcher(resourceRequest);
+            return dispatch(salesforceRequest);
+        }
+    };
+}
+
+const layoutUserStateStorageConfig = {
+    storage: layoutUserStateStorage,
+    statsLogger: layoutUserStateStorageStatsLogger,
+};
+const layoutStorageConfig = {
+    storage: layoutStorage,
+    statsLogger: layoutStorageStatsLogger,
+};
+const objectInfoStorageConfig = {
+    storage: objectInfoStorage,
+    statsLogger: objectInfoStorageStatsLogger,
+};
+/**
+ * Given a path, return the aura storage/logger reference if we store the resource durably for network-based caching.
+ * @param path - The base path for the request.
+ * @returns LdsStorageConfig if we cache that resource, otherwise null.
+ */
+function getStorageAndLogger(path) {
+    if (path.startsWith(UIAPI_GET_LAYOUT) && path.endsWith(UIAPI_GET_LAYOUT_USER_STATE)) {
+        // getLayoutUserState
+        return layoutUserStateStorageConfig;
+    }
+    else if (path.startsWith(UIAPI_GET_LAYOUT) &&
+        path.endsWith(UIAPI_GET_LAYOUT_USER_STATE) === false) {
+        // getLayout
+        return layoutStorageConfig;
+    }
+    else if (path.startsWith(UIAPI_OBJECT_INFO_BATCH_PATH)) {
+        // getObjectInfos
+        return objectInfoStorageConfig;
+    }
+    else if (path.startsWith(UIAPI_OBJECT_INFO_PATH) &&
+        /picklist-values\/[a-zA-Z\d]+\/[a-zA-Z\d]+/.test(path) === false &&
+        /picklist-values\/[a-zA-Z\d]+/.test(path) === false) {
+        // getObjectInfo
+        return objectInfoStorageConfig;
+    }
+    return null;
+}
+const platformFetchAdapter = platformNetworkAdapter(fetchNetworkAdapter);
+/**
+ * Helper function to fetch data, if available in aura storage cache returns that instead of going to network.
+ * @param resourceRequest - {@link ResourceRequest}
+ * @param resourceRequestContext {@link ResourceRequestContext}
+ * @param storageAndLogger - Object containing a reference to aura storage/logger
+ * @param transactionKey - The transaction key, derived from the resource request params.
+ * @returns Promise<FetchResponse<any> - Promise that resolves to a fetch response.
+ */
+function checkLdsStorageCacheOrFetch(resourceRequest, resourceRequestContext, storageAndLogger, transactionKey) {
+    if (!shouldForceRefresh(resourceRequest)) {
+        if (storageAndLogger?.storage) {
+            return storageAndLogger.storage.get(transactionKey).then((cacheResult) => {
+                if (cacheResult !== undefined) {
+                    storageAndLogger.statsLogger.logHits();
+                    // This creates an AuraFetchResponse, should it just be FetchResponse?
+                    return createOkResponse$1(cacheResult);
+                }
+                storageAndLogger.statsLogger.logMisses();
+                return platformFetchAdapter(resourceRequest, resourceRequestContext);
+            }, () => {
+                return platformFetchAdapter(resourceRequest, resourceRequestContext);
+            });
+        }
+    }
+    return platformFetchAdapter(resourceRequest, resourceRequestContext);
+}
+
+// noop implementation for when one is not provided
+let internalRequestTracker = {
+    registerHandler: (_request, _name, _loadedCheck) => { },
+    markFinished: (_request) => { },
+};
+// noop implementation for when one is not provided
+let internalRequestLogger = {
+    resolve: (_request, _response) => { },
+    reject: (_request, _error) => { },
+};
+/**
+ * Wrapper around fetch network adapter from luvio
+ *
+ * @returns fetchNetworkAdapter {@link NetworkAdapter}
+ */
+function setupFetchNetworkAdapter() {
+    return async (resourceRequest, resourceRequestContext) => {
+        return fetchNetworkAdapter(resourceRequest);
+    };
+}
+/**
+ * Helper function to make the fetch network call.
+ * @param resourceRequest - {@link ResourceRequest}
+ * @param resourceRequestContext {@link ResourceRequestContext}
+ * @returns Promise<FetchResponse<any>>
+ */
+function handleSendFetchRequest(resourceRequest, resourceRequestContext) {
+    const { baseUri, basePath } = resourceRequest;
+    const path = `${baseUri}${basePath}`;
+    const storageAndLogger = getStorageAndLogger(path);
+    const transactionKey = getTransactionKey$1(resourceRequest);
+    const response = checkLdsStorageCacheOrFetch(resourceRequest, resourceRequestContext, storageAndLogger, transactionKey);
+    internalRequestTracker.registerHandler(response, 'lds-inflight-network-request', () => {
+        // return false until we signal we are finished
+        return false;
+    });
+    response
+        .then((value) => {
+        if (storageAndLogger !== null && storageAndLogger.storage !== null) {
+            storageAndLogger.storage.set(transactionKey, value.body).catch((_error) => { });
+        }
+        internalRequestLogger.resolve(resourceRequest, value);
+    })
+        .catch((error) => {
+        internalRequestLogger.reject(resourceRequest, error);
+    });
+    return response.finally(() => {
+        internalRequestTracker.markFinished(response);
+    });
+}
+/**
+ * Wrapper around fetch network adapter from luvio
+ *
+ * @param requestTracker
+ * @param requestLogger
+ * @returns lexNetworkAdapter {@link NetworkAdapter}
+ */
+function setupLexNetworkAdapter(requestTracker, requestLogger) {
+    internalRequestTracker = requestTracker || internalRequestTracker;
+    internalRequestLogger = requestLogger || internalRequestLogger;
+    return async (resourceRequest, resourceRequestContext) => {
+        return handleSendFetchRequest(resourceRequest, resourceRequestContext);
+    };
+}
+
+const NO_OP = () => { };
+// For use by callers within this module to instrument interesting things.
+const instrumentation = {
+    log: NO_OP,
+    error: NO_OP,
+};
+/**
+ * Allows external modules (typically a runtime environment) to set
+ * instrumentation hooks for this module. Note that the hooks are
+ * incremental - hooks not suppiled in newInstrumentation will retain
+ * their previous values. The default instrumentation hooks are no-ops.
+ *
+ * @param newInstrumentation instrumentation hooks to be overridden
+ */
+function instrument(newInstrumentation) {
+    Object.assign(instrumentation, newInstrumentation);
+}
+
+export { instrument, setupFetchNetworkAdapter, setupLexNetworkAdapter };
+// version: 1.332.0-fe34ef5c6f

package/dist/types/__mocks__/@salesforce/lds-environment-settings.d.ts

@@ -0,0 +1,2 @@
+export declare function getEnvironmentSetting(): void;
+export declare const EnvironmentSettings: {};

package/dist/types/__mocks__/@salesforce/lds-instrumentation.d.ts

@@ -0,0 +1,7 @@
+export declare const instrumentation: {
+    instrumentAdapter: (adapter: any) => any;
+};
+export declare function registerLdsCacheStats(): {
+    logHits(): void;
+    logMisses(): void;
+};

package/dist/types/__mocks__/aura-storage.d.ts

@@ -0,0 +1,19 @@
+declare class Storage {
+    _entries: {
+        [key: string]: any;
+    };
+    get(key: string): Promise<any>;
+    set(key: string, value: any): Promise<void>;
+    clear(): Promise<void>;
+    getSize(): Promise<number>;
+    isPersistent(): boolean;
+}
+declare const _default: {
+    initStorage({ name }: {
+        name: string;
+    }): Storage;
+    getStorage(name: string): Storage;
+    deleteStorage(name: string): void;
+    __reset(): Promise<void>;
+};
+export default _default;

package/dist/types/__mocks__/aura.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="jest" />
+declare const executeGlobalControllerRawResponse: jest.Mock<any, any, any>;
+export { executeGlobalControllerRawResponse };

package/dist/types/__mocks__/instrumentation/service.d.ts

@@ -0,0 +1,33 @@
+export declare function counter(): {
+    increment(): void;
+    decrement(): void;
+    getValue(): void;
+    reset(): void;
+};
+export declare function gauge(): {
+    setValue(): void;
+    getValue(): void;
+    reset(): void;
+};
+export declare function mark(): void;
+export declare function markStart(): void;
+export declare function markEnd(): void;
+export declare function perfStart(): void;
+export declare function perfEnd(): void;
+export declare function percentileHistogram(): {
+    update(): void;
+    getValue(): void;
+    reset(): void;
+};
+export declare function time(): void;
+export declare function timer(): {
+    addDuration(): void;
+    getValue(): void;
+    time(): void;
+};
+export declare function registerCacheStats(): {
+    logHits(): void;
+    logMisses(): void;
+};
+export declare function registerPlugin(): void;
+export declare function registerPeriodicLogger(): void;

package/dist/types/instrumentation.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Instrumentation hooks exposed by this module.
+ */
+export interface FetchNetworkInstrumentation {
+    /**
+     * Used to send logs to Splunk
+     */
+    log(message: string): void;
+    /**
+     * Used to record an error, which will also be sent to Splunk, but also could be used
+     * for sending error counts to Argus
+     */
+    error(err: Error | string): void;
+}
+export declare const instrumentation: FetchNetworkInstrumentation;
+/**
+ * Allows external modules (typically a runtime environment) to set
+ * instrumentation hooks for this module. Note that the hooks are
+ * incremental - hooks not suppiled in newInstrumentation will retain
+ * their previous values. The default instrumentation hooks are no-ops.
+ *
+ * @param newInstrumentation instrumentation hooks to be overridden
+ */
+export declare function instrument(newInstrumentation: Partial<FetchNetworkInstrumentation>): void;

package/dist/types/main.d.ts

@@ -0,0 +1,3 @@
+export { setupFetchNetworkAdapter, setupLexNetworkAdapter } from './networkAdapter';
+export type { RequestLogger, RequestTracker } from './networkAdapter';
+export { instrument, FetchNetworkInstrumentation } from './instrumentation';

package/dist/types/networkAdapter.d.ts

@@ -0,0 +1,27 @@
+import type { NetworkAdapter, ResourceRequest } from '@luvio/engine';
+export type RequestTracker = {
+    registerHandler: (request: any, name: string, loadedCheck: () => boolean) => void;
+    markFinished: (request: any) => void;
+};
+export type RequestLogger = {
+    resolve: (request: ResourceRequest, response: any) => void;
+    reject: (request: ResourceRequest, error: Error) => void;
+};
+export declare function getTrackerAndLoggerForTest(): {
+    tracker: RequestTracker;
+    logger: RequestLogger;
+};
+/**
+ * Wrapper around fetch network adapter from luvio
+ *
+ * @returns fetchNetworkAdapter {@link NetworkAdapter}
+ */
+export declare function setupFetchNetworkAdapter(): NetworkAdapter;
+/**
+ * Wrapper around fetch network adapter from luvio
+ *
+ * @param requestTracker
+ * @param requestLogger
+ * @returns lexNetworkAdapter {@link NetworkAdapter}
+ */
+export declare function setupLexNetworkAdapter(requestTracker?: RequestTracker, requestLogger?: RequestLogger): NetworkAdapter;

package/dist/types/utils.d.ts

@@ -0,0 +1,23 @@
+import type { CacheStatsLogger } from 'instrumentation/service';
+import type { AuraStorage } from '@salesforce/lds-aura-storage';
+import type { FetchResponse, ResourceRequest, ResourceRequestContext } from '@luvio/engine';
+type LdsStorageConfig = {
+    storage: AuraStorage | null;
+    statsLogger: CacheStatsLogger;
+};
+/**
+ * Given a path, return the aura storage/logger reference if we store the resource durably for network-based caching.
+ * @param path - The base path for the request.
+ * @returns LdsStorageConfig if we cache that resource, otherwise null.
+ */
+export declare function getStorageAndLogger(path: string): LdsStorageConfig | null;
+/**
+ * Helper function to fetch data, if available in aura storage cache returns that instead of going to network.
+ * @param resourceRequest - {@link ResourceRequest}
+ * @param resourceRequestContext {@link ResourceRequestContext}
+ * @param storageAndLogger - Object containing a reference to aura storage/logger
+ * @param transactionKey - The transaction key, derived from the resource request params.
+ * @returns Promise<FetchResponse<any> - Promise that resolves to a fetch response.
+ */
+export declare function checkLdsStorageCacheOrFetch(resourceRequest: ResourceRequest, resourceRequestContext: ResourceRequestContext, storageAndLogger: LdsStorageConfig | null, transactionKey: string): Promise<FetchResponse<any>>;
+export {};

package/package.json

@@ -0,0 +1,43 @@
+{
+    "name": "@salesforce/lds-network-fetch",
+    "version": "1.332.0",
+    "license": "SEE LICENSE IN LICENSE.txt",
+    "description": "LDS Network Adapter using fetch",
+    "main": "dist/ldsNetworkFetch.js",
+    "module": "dist/ldsNetworkFetch.js",
+    "types": "dist/types/main.d.ts",
+    "files": [
+        "dist"
+    ],
+    "exports": {
+        ".": {
+            "types": "./dist/types/main.d.ts",
+            "import": "./dist/ldsNetworkFetch.js",
+            "default": "./dist/ldsNetworkFetch.js"
+        }
+    },
+    "sfdc": {
+        "path": "forcelds/ldsNetworkFetch/",
+        "publishedFileName": "ldsNetworkFetch.js",
+        "overrides": {
+            "artifactDirectory": "dist",
+            "outputModuleName": "ldsNetworkFetch"
+        }
+    },
+    "scripts": {
+        "prepare": "yarn build",
+        "build": "rollup --bundleConfigAsCjs --config rollup.config.js",
+        "clean": "rm -rf dist",
+        "test:perf": "best",
+        "test:unit": "jest",
+        "test:debug": "node --inspect-brk ../../node_modules/.bin/jest --runInBand",
+        "release:corejar": "yarn build && ../core-build/scripts/core.js --name=lds-network-fetch"
+    },
+    "dependencies": {
+        "@luvio/engine": "0.156.5",
+        "@luvio/network-adapter-fetch": "0.156.5"
+    },
+    "devDependencies": {
+        "@salesforce/lds-network-aura": "^1.332.0"
+    }
+}