@salesforce/lds-network-adapter 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/ldsNetwork.js

@@ -0,0 +1,472 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { HttpStatusCode } from '@luvio/engine';
+
+const { parse, stringify } = JSON;
+const { join, push, unshift } = Array.prototype;
+const { isArray } = Array;
+const { entries, keys } = Object;
+
+const UI_API_BASE_URI = '/services/data/v66.0/ui-api';
+
+let instrumentation = {
+    aggregateUiChunkCount: (_cb) => { },
+    aggregateUiConnectError: () => { },
+    duplicateRequest: (_cb) => { },
+    getRecordAggregateInvoke: () => { },
+    getRecordAggregateResolve: (_cb) => { },
+    getRecordAggregateReject: (_cb) => { },
+    getRecordAggregateRetry: () => { },
+    getRecordNormalInvoke: () => { },
+    networkRateLimitExceeded: () => { },
+};
+function instrument(newInstrumentation) {
+    instrumentation = Object.assign(instrumentation, newInstrumentation);
+}
+
+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.Ok,
+        body,
+        statusText: 'ok',
+        headers: {},
+        ok: true,
+    };
+}
+function getErrorResponseText(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 createErrorResponse(status, body) {
+    return {
+        status,
+        body,
+        statusText: getErrorResponseText(status),
+        headers: {},
+        ok: false,
+    };
+}
+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] = 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) {
+    instrumentation.getRecordAggregateInvoke();
+    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.ServerError, {
+                error: 'No response body in executeAggregateUi found',
+            });
+        }
+        const merged = body.compositeResponse.reduce((seed, response) => {
+            if (response.httpStatusCode !== HttpStatusCode.Ok) {
+                instrumentation.getRecordAggregateReject(() => recordId);
+                throw createErrorResponse(HttpStatusCode.ServerError, {
+                    error: response.message,
+                });
+            }
+            if (seed === null) {
+                return response.body;
+            }
+            return mergeRecordFields(seed, response.body);
+        }, null);
+        instrumentation.getRecordAggregateResolve(() => {
+            return {
+                recordId,
+                apiName: merged.apiName,
+            };
+        });
+        return createOkResponse(merged);
+    }, (err) => {
+        instrumentation.getRecordAggregateReject(() => recordId);
+        // 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.BadRequest && body !== undefined) {
+        return (body.statusCode === HttpStatusCode.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);
+    // W-12245125: Emit chunk size metrics
+    instrumentation.aggregateUiChunkCount(() => compositeRequest.length);
+    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)) {
+            // We are hitting rate limiting, add some metrics
+            instrumentation.networkRateLimitExceeded();
+        }
+        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);
+        }
+    };
+}
+
+export { platformNetworkAdapter as default, instrument };

package/dist/types/dispatch/dedupe.d.ts

@@ -0,0 +1,10 @@
+import type { Dispatcher, SalesforceResourceRequest } from './main';
+export declare function isResourceRequestDedupable(resourceRequest: SalesforceResourceRequest): boolean;
+/**
+  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.
+*/
+export declare const dedupeRequest: Dispatcher;

package/dist/types/dispatch/execute-aggregate-ui.d.ts

@@ -0,0 +1,26 @@
+import type { FetchResponse, NetworkAdapter, ResourceRequest, ResourceRequestContext } from '@luvio/engine';
+import type { RecordRepresentation } from '@salesforce/lds-adapters-uiapi';
+export declare const MAX_AGGREGATE_UI_CHUNK_LIMIT = 50;
+export interface CompositeRequest {
+    url: string;
+    referenceId: string;
+}
+export declare function mergeRecordFields(first: RecordRepresentation, second: RecordRepresentation): RecordRepresentation;
+/** Invoke executeAggregateUi Aura controller.  This is only to be used with large getRecord requests that
+ *  would otherwise cause a query length exception.
+ */
+export declare function dispatchSplitRecordAggregateUiAction(recordId: string, networkAdapter: NetworkAdapter, resourceRequest: ResourceRequest, resourceRequestContext: ResourceRequestContext): Promise<FetchResponse<unknown>>;
+export declare function shouldUseAggregateUiForGetRecord(fieldsArray: string, optionalFieldsArray: string): boolean;
+interface AggregateUiParams {
+    fields?: string[];
+    optionalFields?: string[];
+}
+export declare function buildAggregateUiUrl(params: AggregateUiParams, resourceRequest: ResourceRequest): string;
+export interface GetRecordCompositeRequestParams {
+    fieldsArray: Array<string>;
+    optionalFieldsArray: Array<string>;
+    fieldsLength: number;
+    optionalFieldsLength: number;
+}
+export declare function buildGetRecordByFieldsCompositeRequest(resourceRequest: ResourceRequest, recordsCompositeRequest: GetRecordCompositeRequestParams): CompositeRequest[];
+export {};

package/dist/types/dispatch/main.d.ts

@@ -0,0 +1,9 @@
+import type { FetchResponse, NetworkAdapter, ResourceRequest, ResourceRequestContext } from '@luvio/engine';
+export interface SalesforceResourceRequest {
+    networkAdapter: NetworkAdapter;
+    resourceRequest: ResourceRequest;
+    resourceRequestContext: ResourceRequestContext;
+}
+export type Dispatcher = (req: SalesforceResourceRequest) => Promise<FetchResponse<unknown>>;
+export declare const defaultDispatcher: Dispatcher;
+export declare function getDispatcher(resourceRequest: ResourceRequest): Dispatcher;

package/dist/types/dispatch/records.d.ts

@@ -0,0 +1,3 @@
+import type { ResourceRequest } from '@luvio/engine';
+import type { Dispatcher } from './main';
+export declare function matchRecordsHandlers(path: string, resourceRequest: ResourceRequest): Dispatcher | null;

package/dist/types/dispatch/related-lists.d.ts

@@ -0,0 +1,3 @@
+import type { ResourceRequest } from '@luvio/engine';
+export declare function isRelatedListPostRecordsResourceRequest(resourceRequest: ResourceRequest): boolean;
+export declare function convertPostRelatedListRecordsToGet(resourceRequest: ResourceRequest): ResourceRequest;

package/dist/types/instrumentation.d.ts

@@ -0,0 +1,17 @@
+import type { ResourceRequest } from '@luvio/engine';
+export declare let instrumentation: {
+    aggregateUiChunkCount: (_cb: () => number) => void;
+    aggregateUiConnectError: () => void;
+    duplicateRequest: (_cb: () => ResourceRequest) => void;
+    getRecordAggregateInvoke: () => void;
+    getRecordAggregateResolve: (_cb: () => {
+        recordId: string;
+        apiName: string;
+    }) => void;
+    getRecordAggregateReject: (_cb: () => string) => void;
+    getRecordAggregateRetry: () => void;
+    getRecordNormalInvoke: () => void;
+    networkRateLimitExceeded: () => void;
+};
+export declare function instrument(newInstrumentation: Partial<typeof instrumentation>): void;
+export type Instrument = typeof instrument;

package/dist/types/language.d.ts

@@ -0,0 +1,16 @@
+declare const parse: (text: string, reviver?: ((this: any, key: string, value: any) => any) | undefined) => any, 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;
+};
+declare const join: (separator?: string | undefined) => string, push: (...items: any[]) => number, unshift: (...items: any[]) => number;
+declare const isArray: (arg: any) => arg is any[];
+declare const entries: {
+    <T>(o: {
+        [s: string]: T;
+    } | ArrayLike<T>): [string, T][];
+    (o: {}): [string, any][];
+}, keys: {
+    (o: object): string[];
+    (o: {}): string[];
+};
+export { isArray as ArrayIsArray, entries as ObjectEntries, keys as ObjectKeys, parse as JSONParse, stringify as JSONStringify, join as ArrayPrototypeJoin, push as ArrayPrototypePush, unshift as ArrayPrototypeUnshift, };

package/dist/types/main.d.ts

@@ -0,0 +1,8 @@
+import type { NetworkAdapter } from '@luvio/engine';
+import type { Instrument } from './instrumentation';
+export { instrument, Instrument } from './instrumentation';
+export default function platformNetworkAdapter(baseNetworkAdapter: NetworkAdapter): NetworkAdapter;
+export type Registration = {
+    id: '@salesforce/lds-network-adapter';
+    instrument: Instrument;
+};

package/dist/types/token-bucket.d.ts

@@ -0,0 +1,28 @@
+interface RateLimitConfig {
+    bucketCapacity: number;
+    fillsPerSecond: number;
+}
+export declare const RATE_LIMIT_CONFIG: RateLimitConfig;
+export declare class TokenBucket {
+    bucketCapacity: number;
+    readonly refillTokensPerMilliSecond: number;
+    tokens: number;
+    private lastRefillTime;
+    /**
+     * 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: RateLimitConfig);
+    /**
+     * 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: number): boolean;
+    private refill;
+}
+declare const _default: TokenBucket;
+export default _default;

package/dist/types/uiapi-base.d.ts

@@ -0,0 +1 @@
+export declare const UI_API_BASE_URI = "/services/data/v66.0/ui-api";

package/package.json

@@ -0,0 +1,32 @@
+{
+    "name": "@salesforce/lds-network-adapter",
+    "version": "0.1.0-dev1",
+    "license": "SEE LICENSE IN LICENSE.txt",
+    "description": "LDS shared Network Adapter code for Lightning Platform",
+    "main": "dist/ldsNetwork.js",
+    "module": "dist/ldsNetwork.js",
+    "types": "dist/types/main.d.ts",
+    "files": [
+        "dist"
+    ],
+    "exports": {
+        ".": {
+            "types": "./dist/types/main.d.ts",
+            "import": "./dist/ldsNetwork.js",
+            "default": "./dist/ldsNetwork.js"
+        }
+    },
+    "scripts": {
+        "prepare": "yarn build",
+        "build": "rollup --bundleConfigAsCjs --config rollup.config.js",
+        "clean": "rm -rf dist",
+        "test:unit": "jest",
+        "test:debug": "node --inspect-brk ../../node_modules/.bin/jest --runInBand"
+    },
+    "dependencies": {
+        "@luvio/engine": "0.158.7"
+    },
+    "devDependencies": {
+        "@salesforce/lds-adapters-uiapi": "^0.1.0-dev1"
+    }
+}