@salesforce/lds-runtime-mobile 1.316.0 → 1.317.0

package/dist/main.js

@@ -53,7 +53,7 @@ import graphqlL2AdapterGate from '@salesforce/gate/lmr.graphqlL2Adapter';
 
 const { parse: parse$7, stringify: stringify$7 } = JSON;
 const { join: join$2, push: push$3, unshift } = Array.prototype;
-const { isArray: isArray$5 } = Array;
+const { isArray: isArray$6 } = Array;
 const { entries: entries$6, keys: keys$9 } = Object;
 
 const UI_API_BASE_URI = '/services/data/v63.0/ui-api';
@@ -278,7 +278,7 @@ const getRecordDispatcher = (req) => {
         }
     }
     const recordId = urlParams.recordId;
-    const fieldsArray = fields !== undefined && isArray$5(fields) ? fields : [];
+    const fieldsArray = fields !== undefined && isArray$6(fields) ? fields : [];
     const optionalFieldsArray = optionalFields !== undefined && Array.isArray(optionalFields)
         ? optionalFields
         : [];
@@ -1844,7 +1844,7 @@ var QueueOperationType;
 
 const { keys: keys$7, create: create$7, assign: assign$7, values: values$4 } = Object;
 const { stringify: stringify$6, parse: parse$6 } = JSON;
-const { isArray: isArray$4 } = Array;
+const { isArray: isArray$5 } = Array;
 
 const DraftIdMappingKeyPrefix240 = 'DraftIdMapping::';
 const DRAFT_ID_MAPPINGS_SEGMENT = 'DRAFT_ID_MAPPINGS';
@@ -2211,9 +2211,6 @@ class DurableDraftQueue {
     async getQueueActions() {
         const drafts = (await this.draftStore.getAllDrafts());
         const queue = [];
-        if (drafts === undefined) {
-            return queue;
-        }
         drafts.forEach((draft) => {
             if (draft.id === this.uploadingActionId) {
                 draft.status = DraftActionStatus.Uploading;
@@ -2765,23 +2762,15 @@ class DurableDraftStore {
                 for (let i = 0, len = keys$1.length; i < len; i++) {
                     const entry = durableEntries[keys$1[i]];
                     const action = entry.data;
-                    if (action !== undefined) {
-                        if (process.env.NODE_ENV !== 'production') {
-                            // the `version` property was introduced in 242, we should assert version
-                            // exists once we are sure there are no durable stores that contain
-                            // versionless actions
-                            if (action.version && action.version !== '242.0.0') {
-                                return Promise.reject('Unexpected draft action version found in the durable store');
-                            }
-                        }
-                        draftStore[action.id] = action;
-                    }
-                    else {
-                        if (process.env.NODE_ENV !== 'production') {
-                            const err = new Error('Expected draft action to be defined in the durable store');
-                            return Promise.reject(err);
+                    if (process.env.NODE_ENV !== 'production') {
+                        // the `version` property was introduced in 242, we should assert version
+                        // exists once we are sure there are no durable stores that contain
+                        // versionless actions
+                        if (action.version && action.version !== '242.0.0') {
+                            return Promise.reject('Unexpected draft action version found in the durable store');
                         }
                     }
+                    draftStore[action.id] = action;
                 }
                 return this.runQueuedOperations();
             })
@@ -2817,494 +2806,6 @@ class DurableDraftStore {
     }
 }
 
-const HTTP_HEADER_RETRY_AFTER = 'Retry-After';
-const HTTP_HEADER_IDEMPOTENCY_KEY = 'Idempotency-Key';
-const ERROR_CODE_IDEMPOTENCY_FEATURE_NOT_ENABLED = 'IDEMPOTENCY_FEATURE_NOT_ENABLED';
-const ERROR_CODE_IDEMPOTENCY_NOT_SUPPORTED = 'IDEMPOTENCY_NOT_SUPPORTED';
-const ERROR_CODE_IDEMPOTENCY_KEY_USED_DIFFERENT_USER = 'IDEMPOTENCY_KEY_USED_DIFFERENT_USER';
-const ERROR_CODE_IDEMPOTENCY_CONCURRENT_REQUEST = 'IDEMPOTENCY_CONCURRENT_REQUEST';
-const ERROR_CODE_IDEMPOTENCY_KEY_ALREADY_USED = 'IDEMPOTENCY_KEY_ALREADY_USED';
-const ERROR_CODE_IDEMPOTENCY_BACKEND_OPERATION_ERROR = 'IDEMPOTENCY_BACKEND_OPERATION_ERROR';
-/**
- * Get the retry after in milliseconds from the response headers, undefined if not specified.
- * The header could have two different format.
- * Retry-After: <http-date>, like Wed, 21 Oct 2015 07:28:00 GMT
- * Retry-After: <delay-seconds>, like 1.5s
- * @param headers http headers
- * @returns the time to delat in millisconds.
- */
-function getRetryAfterInMs(headers) {
-    const retryAfterHeader = headers && headers[HTTP_HEADER_RETRY_AFTER];
-    if (retryAfterHeader === undefined) {
-        return undefined;
-    }
-    const delayInSecond = parseFloat(retryAfterHeader);
-    if (retryAfterHeader === delayInSecond.toString()) {
-        return Math.round(delayInSecond * 1000);
-    }
-    const delayUntilDateTime = Date.parse(retryAfterHeader);
-    if (isNaN(delayUntilDateTime)) {
-        return undefined;
-    }
-    return delayUntilDateTime - Date.now();
-}
-
-const DEFAULT_FIELD_LAST_MODIFIED_DATE$1 = 'LastModifiedDate';
-const DEFAULT_FIELD_CREATED_DATE$1 = 'CreatedDate';
-class AbstractResourceRequestActionHandler {
-    constructor(draftQueue, networkAdapter, getLuvio) {
-        this.draftQueue = draftQueue;
-        this.networkAdapter = networkAdapter;
-        this.getLuvio = getLuvio;
-        // NOTE[W-12567340]: This property stores in-memory mappings between draft
-        // ids and canonical ids for the current session. Having a local copy of
-        // these mappings is necessary to avoid a race condition between publishing
-        // new mappings to the durable store and those mappings being loaded into
-        // the luvio store redirect table, during which a new draft might be enqueued
-        // which would not see a necessary mapping.
-        this.ephemeralRedirects = {};
-        // determined by Server setup.
-        this.isIdempotencySupported = true;
-        // idempotency write flag set by lds
-        this.isLdsIdempotencyWriteDisabled = ldsIdempotencyWriteDisabled.isOpen({
-            fallback: false,
-        });
-        this.isBackdatingEnabled = ldsBackdatingEnabled.isOpen({ fallback: false });
-    }
-    enqueue(data) {
-        return this.draftQueue.enqueue(this.handlerId, data);
-    }
-    async handleAction(action, actionCompleted, actionErrored) {
-        const { data: request } = action;
-        // no context is stored in draft action
-        try {
-            const response = await this.networkAdapter(request, {});
-            if (response.ok) {
-                await actionCompleted({
-                    ...action,
-                    response,
-                    status: DraftActionStatus.Completed,
-                });
-                return ProcessActionResult.ACTION_SUCCEEDED;
-            }
-            let shouldRetry = false;
-            let retryDelayInMs = undefined;
-            let actionDataChanged = false;
-            let updatedAction = action;
-            if (request && request.headers && request.headers[HTTP_HEADER_IDEMPOTENCY_KEY]) {
-                const status = response.status;
-                switch (status) {
-                    case 408 /* IdempotentWriteSpecificHttpStatusCode.RequestTimeout */:
-                    case 503 /* IdempotentWriteSpecificHttpStatusCode.ServiceUnavailable */:
-                        retryDelayInMs = getRetryAfterInMs(response.headers);
-                        shouldRetry = true;
-                        break;
-                    case HttpStatusCode.ServerError: {
-                        shouldRetry = true;
-                        if (this.handleIdempotencyServerError(response.body, updatedAction, false, ERROR_CODE_IDEMPOTENCY_BACKEND_OPERATION_ERROR)) {
-                            this.isIdempotencySupported = false;
-                            retryDelayInMs = 0;
-                            actionDataChanged = true;
-                        }
-                        break;
-                    }
-                    case 409 /* IdempotentWriteSpecificHttpStatusCode.Conflict */: {
-                        if (this.isUiApiErrors(response.body)) {
-                            const errorCode = response.body[0].errorCode;
-                            if (this.handleIdempotencyServerError(response.body, updatedAction, true, ERROR_CODE_IDEMPOTENCY_KEY_USED_DIFFERENT_USER)) {
-                                retryDelayInMs = 0;
-                                actionDataChanged = true;
-                            }
-                            else if (errorCode === ERROR_CODE_IDEMPOTENCY_CONCURRENT_REQUEST) {
-                                retryDelayInMs = getRetryAfterInMs(response.headers);
-                            }
-                            shouldRetry = true;
-                        }
-                        break;
-                    }
-                    case HttpStatusCode.BadRequest: {
-                        if (this.handleIdempotencyServerError(response.body, updatedAction, false, ERROR_CODE_IDEMPOTENCY_FEATURE_NOT_ENABLED, ERROR_CODE_IDEMPOTENCY_NOT_SUPPORTED)) {
-                            retryDelayInMs = 0;
-                            actionDataChanged = true;
-                            shouldRetry = true;
-                        }
-                        break;
-                    }
-                    case 422 /* IdempotentWriteSpecificHttpStatusCode.UnProcessableEntity */: {
-                        if (this.handleIdempotencyServerError(response.body, updatedAction, true, ERROR_CODE_IDEMPOTENCY_KEY_ALREADY_USED)) {
-                            retryDelayInMs = 0;
-                            actionDataChanged = true;
-                            shouldRetry = true;
-                        }
-                        break;
-                    }
-                }
-            }
-            if (this.isBackdatingEnabled &&
-                response.status === HttpStatusCode.BadRequest &&
-                this.isBackdatingError(response.body, action)) {
-                updatedAction.timestamp = Date.now();
-                updatedAction.data.body.fields = {
-                    ...updatedAction.data.body.fields,
-                    LastModifiedDate: new Date(updatedAction.timestamp).toISOString(),
-                };
-                if (this.hasIdempotencySupport() &&
-                    updatedAction.data.headers[HTTP_HEADER_IDEMPOTENCY_KEY]) {
-                    updatedAction.data.headers[HTTP_HEADER_IDEMPOTENCY_KEY] = uuidv4();
-                }
-                shouldRetry = true;
-                actionDataChanged = true;
-            }
-            await actionErrored(shouldRetry
-                ? updatedAction
-                : {
-                    ...updatedAction,
-                    error: response,
-                    status: DraftActionStatus.Error,
-                }, shouldRetry, retryDelayInMs, actionDataChanged);
-            return ProcessActionResult.ACTION_ERRORED;
-        }
-        catch (e) {
-            await actionErrored(action, true);
-            return ProcessActionResult.NETWORK_ERROR;
-        }
-    }
-    // true if response is an idempotency server error. updates or deletes idempotency key if the reponse is idempotency related error. Idempotency related error is in format of UiApiError array.
-    handleIdempotencyServerError(responseBody, action, updateIdempotencyKey, ...targetErrorCodes) {
-        if (this.isUiApiErrors(responseBody)) {
-            const errorCode = responseBody[0].errorCode;
-            if (targetErrorCodes.includes(errorCode)) {
-                action.data.headers = action.data.headers || {};
-                if (updateIdempotencyKey) {
-                    action.data.headers[HTTP_HEADER_IDEMPOTENCY_KEY] = uuidv4();
-                }
-                else {
-                    delete action.data.headers[HTTP_HEADER_IDEMPOTENCY_KEY];
-                }
-                return true;
-            }
-        }
-        return false;
-    }
-    // checks if the body is an array of UiApiError. Sometimes the body has `enhancedErrorType` field as an error indicator(one example is the field validation failure). In such case Action being processed updates to an Error Action.
-    isUiApiErrors(body) {
-        return body !== undefined && isArray$4(body) && body.length > 0 && body[0].errorCode;
-    }
-    isBackdatingError(body, action) {
-        if (body.enhancedErrorType &&
-            body.enhancedErrorType === 'RecordError' &&
-            body.output &&
-            body.output.errors &&
-            isArray$4(body.output.errors) &&
-            body.output.errors.length > 0 &&
-            action.data.body &&
-            action.data.body.fields &&
-            action.data.body.fields[DEFAULT_FIELD_LAST_MODIFIED_DATE$1]) {
-            return body.output.errors.some((error) => error.errorCode === 'CollisionDetectedException');
-        }
-        return false;
-    }
-    async buildPendingAction(request, queue) {
-        const targetId = await this.getIdFromRequest(request);
-        const tag = this.buildTagForTargetId(targetId);
-        const handlerActions = queue.filter((x) => x.handler === this.handlerId);
-        if (request.method === 'post' && actionsForTag(tag, handlerActions).length > 0) {
-            return Promise.reject(new Error('Cannot enqueue a POST draft action with an existing tag'));
-        }
-        if (deleteActionsForTag(tag, handlerActions).length > 0) {
-            return Promise.reject(new Error('Cannot enqueue a draft action for a deleted record'));
-        }
-        return {
-            handler: this.handlerId,
-            targetId,
-            tag,
-            data: request,
-            status: DraftActionStatus.Pending,
-            id: generateUniqueDraftActionId(queue.map((x) => x.id)),
-            timestamp: Date.now(),
-            metadata: {},
-            version: '242.0.0',
-        };
-    }
-    async handleActionEnqueued(_action) { }
-    handleActionRemoved(action) {
-        return this.reingestRecord(action);
-    }
-    getQueueOperationsForCompletingDrafts(queue, action) {
-        const queueOperations = [];
-        const redirects = this.getRedirectMappings(action);
-        if (redirects !== undefined) {
-            const { length } = queue;
-            for (let i = 0; i < length; i++) {
-                const queueAction = queue[i];
-                // if this queueAction is the action that is completing we can move on,
-                // it is about to be deleted and won't have the draft ID in it
-                if (queueAction.id === action.id) {
-                    continue;
-                }
-                if (isResourceRequestAction(queueAction)) {
-                    let queueOperationMutated = false;
-                    let updatedActionTag = undefined;
-                    let updatedActionTargetId = undefined;
-                    const { tag: queueActionTag, data: queueActionRequest, id: queueActionId, } = queueAction;
-                    let { basePath, body } = queueActionRequest;
-                    let stringifiedBody = stringify$6(body);
-                    // for each redirected ID/key we loop over the operation to see if it needs
-                    // to be updated
-                    for (const { draftId, draftKey, canonicalId, canonicalKey } of redirects) {
-                        if (basePath.search(draftId) >= 0 || stringifiedBody.search(draftId) >= 0) {
-                            basePath = basePath.replace(draftId, canonicalId);
-                            stringifiedBody = stringifiedBody.replace(draftId, canonicalId);
-                            queueOperationMutated = true;
-                        }
-                        // if the action is performed on a previous draft id, we need to replace the action
-                        // with a new one at the updated canonical key
-                        if (queueActionTag === draftKey) {
-                            updatedActionTag = canonicalKey;
-                            updatedActionTargetId = canonicalId;
-                        }
-                    }
-                    if (queueOperationMutated) {
-                        if (updatedActionTag !== undefined && updatedActionTargetId !== undefined) {
-                            const updatedAction = {
-                                ...queueAction,
-                                tag: updatedActionTag,
-                                targetId: updatedActionTargetId,
-                                data: {
-                                    ...queueActionRequest,
-                                    basePath: basePath,
-                                    body: parse$6(stringifiedBody),
-                                },
-                            };
-                            // item needs to be replaced with a new item at the new record key
-                            queueOperations.push({
-                                type: QueueOperationType.Delete,
-                                id: queueActionId,
-                            });
-                            queueOperations.push({
-                                type: QueueOperationType.Add,
-                                action: updatedAction,
-                            });
-                        }
-                        else {
-                            const updatedAction = {
-                                ...queueAction,
-                                data: {
-                                    ...queueActionRequest,
-                                    basePath: basePath,
-                                    body: parse$6(stringifiedBody),
-                                },
-                            };
-                            // item needs to be updated
-                            queueOperations.push({
-                                type: QueueOperationType.Update,
-                                id: queueActionId,
-                                action: updatedAction,
-                            });
-                        }
-                    }
-                }
-            }
-        }
-        // delete completed action
-        queueOperations.push({
-            type: QueueOperationType.Delete,
-            id: action.id,
-        });
-        return queueOperations;
-    }
-    getRedirectMappings(action) {
-        if (action.data.method !== 'post') {
-            return undefined;
-        }
-        const body = action.response.body;
-        const canonicalId = this.getIdFromResponseBody(body);
-        const draftId = action.targetId;
-        if (draftId !== undefined && canonicalId !== undefined && draftId !== canonicalId) {
-            this.ephemeralRedirects[draftId] = canonicalId;
-        }
-        return [
-            {
-                draftId,
-                canonicalId,
-                draftKey: this.buildTagForTargetId(draftId),
-                canonicalKey: this.buildTagForTargetId(canonicalId),
-            },
-        ];
-    }
-    async handleActionCompleted(action, queueOperations, allHandlers) {
-        const { data: request, tag } = action;
-        const { method } = request;
-        if (method === 'delete') {
-            return this.evictKey(tag);
-        }
-        const recordsToIngest = [];
-        recordsToIngest.push({
-            response: action.response.body,
-            synchronousIngest: this.synchronousIngest.bind(this),
-            buildCacheKeysForResponse: this.buildCacheKeysFromResponse.bind(this),
-        });
-        const recordsNeedingReplay = queueOperations.filter((x) => x.type === QueueOperationType.Update);
-        for (const recordNeedingReplay of recordsNeedingReplay) {
-            const { action } = recordNeedingReplay;
-            if (isResourceRequestAction(action)) {
-                // We can't assume the queue operation is for our handler, have to find the handler.
-                const handler = allHandlers.find((h) => h.handlerId === action.handler);
-                if (handler !== undefined) {
-                    const record = await handler.getDataForAction(action);
-                    if (record !== undefined) {
-                        recordsToIngest.push({
-                            response: record,
-                            synchronousIngest: handler.synchronousIngest.bind(handler),
-                            buildCacheKeysForResponse: handler.buildCacheKeysFromResponse.bind(handler),
-                        });
-                    }
-                }
-            }
-        }
-        await this.ingestResponses(recordsToIngest, action);
-    }
-    handleReplaceAction(targetAction, sourceAction) {
-        //reject if the action to replace is a POST action
-        const pendingAction = targetAction;
-        if (pendingAction.data.method === 'post') {
-            throw Error('Cannot replace a POST action');
-        }
-        if (this.isActionOfType(targetAction) &&
-            this.isActionOfType(sourceAction)) {
-            targetAction.status = DraftActionStatus.Pending;
-            targetAction.data = sourceAction.data;
-            return targetAction;
-        }
-        else {
-            throw Error('Incompatible Action types to replace one another');
-        }
-    }
-    mergeActions(targetAction, sourceAction) {
-        const { id: targetId, data: targetData, metadata: targetMetadata, timestamp: targetTimestamp, } = targetAction;
-        const { method: targetMethod, body: targetBody } = targetData;
-        const { data: sourceData, metadata: sourceMetadata } = sourceAction;
-        const { method: sourceMethod, body: sourceBody } = sourceData;
-        if (targetMethod.toLowerCase() === 'delete' || sourceMethod.toLowerCase() === 'delete') {
-            throw Error('Cannot merge DELETE actions.');
-        }
-        if (targetMethod.toLowerCase() === 'patch' && sourceMethod.toLowerCase() === 'post') {
-            // overlaying a POST over a PATCH is not supported
-            throw Error('Cannot merge a POST action over top of a PATCH action.');
-        }
-        // overlay top-level properties, maintain target's timestamp and id
-        const merged = {
-            ...targetAction,
-            ...sourceAction,
-            timestamp: targetTimestamp,
-            id: targetId,
-        };
-        // overlay data
-        // NOTE: we stick to the target's ResourceRequest properties (except body
-        // which is merged) because we don't want to overwrite a POST with a PATCH
-        // (all other cases should be fine or wouldn't have passed pre-requisites)
-        merged.data = {
-            ...targetData,
-            body: this.mergeRequestBody(targetBody, sourceBody),
-        };
-        // Updates Idempotency key if target has one
-        if (targetData.headers && targetData.headers[HTTP_HEADER_IDEMPOTENCY_KEY]) {
-            merged.data.headers[HTTP_HEADER_IDEMPOTENCY_KEY] = uuidv4();
-        }
-        // overlay metadata
-        merged.metadata = { ...targetMetadata, ...sourceMetadata };
-        // put status back to pending to auto upload if queue is active and targed is at the head.
-        merged.status = DraftActionStatus.Pending;
-        return merged;
-    }
-    shouldDeleteActionByTagOnRemoval(action) {
-        return action.data.method === 'post';
-    }
-    updateMetadata(_existingMetadata, incomingMetadata) {
-        return incomingMetadata;
-    }
-    isActionOfType(action) {
-        return action.handler === this.handlerId;
-    }
-    async reingestRecord(action) {
-        const record = await this.getDataForAction(action);
-        if (record !== undefined) {
-            await this.ingestResponses([
-                {
-                    response: record,
-                    synchronousIngest: this.synchronousIngest.bind(this),
-                    buildCacheKeysForResponse: this.buildCacheKeysFromResponse.bind(this),
-                },
-            ], action);
-        }
-        else {
-            await this.evictKey(action.tag);
-        }
-    }
-    // Given an action for this handler this method should return the draft IDs.
-    // Most of the time it will simply be the targetId, but certain handlers might
-    // have multiple draft-created IDs so they would override this to return them.
-    getDraftIdsFromAction(action) {
-        return [action.targetId];
-    }
-    hasIdempotencySupport() {
-        return this.isIdempotencySupported && !this.isLdsIdempotencyWriteDisabled;
-    }
-    async ingestResponses(responses, action) {
-        const luvio = this.getLuvio();
-        await luvio.handleSuccessResponse(() => {
-            if (action.status === DraftActionStatus.Completed) {
-                const mappings = this.getRedirectMappings(action);
-                if (mappings) {
-                    mappings.forEach((mapping) => {
-                        luvio.storeRedirect(mapping.draftKey, mapping.canonicalKey);
-                    });
-                }
-            }
-            for (const entry of responses) {
-                const { response, synchronousIngest } = entry;
-                synchronousIngest(response, action);
-            }
-            return luvio.storeBroadcast();
-        }, 
-        // getTypeCacheKeysRecord uses the response, not the full path factory
-        // so 2nd parameter will be unused
-        () => {
-            const keySet = new StoreKeyMap();
-            for (const entry of responses) {
-                const { response, buildCacheKeysForResponse } = entry;
-                const set = buildCacheKeysForResponse(response);
-                for (const key of set.keys()) {
-                    const value = set.get(key);
-                    if (value !== undefined) {
-                        keySet.set(key, value);
-                    }
-                }
-            }
-            return keySet;
-        });
-    }
-    async evictKey(key) {
-        const luvio = this.getLuvio();
-        await luvio.handleSuccessResponse(() => {
-            luvio.storeEvict(key);
-            return luvio.storeBroadcast();
-        }, () => {
-            return new StoreKeyMap();
-        });
-    }
-}
-function actionsForTag(tag, queue) {
-    return queue.filter((action) => action.tag === tag);
-}
-function deleteActionsForTag(tag, queue) {
-    return queue.filter((action) => action.tag === tag && action.data.method === 'delete');
-}
-function isResourceRequestAction(action) {
-    const dataAsAny = action.data;
-    return (dataAsAny !== undefined && dataAsAny.method !== undefined && dataAsAny.body !== undefined);
-}
-
 /**
  * Denotes what kind of operation a DraftQueueItem represents.
  */
@@ -3340,7 +2841,7 @@ var DraftQueueOperationType;
  * @param action
  */
 function getOperationTypeFrom(action) {
-    if (isResourceRequestAction(action)) {
+    if (isResourceRequestAction$1(action)) {
         if (action.data !== undefined && action.data.method !== undefined) {
             switch (action.data.method) {
                 case 'put':
@@ -3581,7 +3082,7 @@ class DraftManager {
         if (isDraftError(action)) {
             // We should always return an array, if the body is just a dictionary,
             // stick it in an array
-            const body = isArray$4(action.error.body) ? action.error.body : [action.error.body];
+            const body = isArray$5(action.error.body) ? action.error.body : [action.error.body];
             const bodyString = stringify$6(body);
             item.error = {
                 status: action.error.status || 0,
@@ -3680,6 +3181,10 @@ class DraftManager {
         });
     }
 }
+function isResourceRequestAction$1(action) {
+    const dataAsAny = action.data;
+    return (dataAsAny !== undefined && dataAsAny.method !== undefined && dataAsAny.body !== undefined);
+}
 
 function makeEnvironmentDraftAware(luvio, env, durableStore, handlers, draftQueue) {
     const draftMetadata = {};
@@ -3808,7 +3313,7 @@ function objectsDeepEqual(lhs, rhs) {
 const { keys: keys$6, values: values$3, create: create$6, assign: assign$6, freeze: freeze$2, entries: entries$5 } = Object;
 const { stringify: stringify$5, parse: parse$5 } = JSON;
 const { shift: shift$1 } = Array.prototype;
-const { isArray: isArray$3, from: from$2 } = Array;
+const { isArray: isArray$4, from: from$3 } = Array;
 
 /**
  * Retrieves a denormalized record from the store
@@ -4036,7 +3541,7 @@ function isRequestForGetRecords(request) {
  */
 function extractRecordIdsFromResourceRequest(request) {
     const ids = request.urlParams['recordIds'];
-    if (isArray$3(ids) === false) {
+    if (isArray$4(ids) === false) {
         return undefined;
     }
     return ids;
@@ -4207,6 +3712,499 @@ function makeEnvironmentUiApiRecordDraftAware(luvio, options, env) {
     return create$6(adapterSpecificEnvironments, {});
 }
 
+const { keys: keys$5, create: create$5, assign: assign$5, entries: entries$4 } = Object;
+const { stringify: stringify$4, parse: parse$4 } = JSON;
+const { push: push$2, join: join$1, slice: slice$1, shift } = Array.prototype;
+const { isArray: isArray$3, from: from$2 } = Array;
+
+const HTTP_HEADER_RETRY_AFTER = 'Retry-After';
+const HTTP_HEADER_IDEMPOTENCY_KEY = 'Idempotency-Key';
+const ERROR_CODE_IDEMPOTENCY_FEATURE_NOT_ENABLED = 'IDEMPOTENCY_FEATURE_NOT_ENABLED';
+const ERROR_CODE_IDEMPOTENCY_NOT_SUPPORTED = 'IDEMPOTENCY_NOT_SUPPORTED';
+const ERROR_CODE_IDEMPOTENCY_KEY_USED_DIFFERENT_USER = 'IDEMPOTENCY_KEY_USED_DIFFERENT_USER';
+const ERROR_CODE_IDEMPOTENCY_CONCURRENT_REQUEST = 'IDEMPOTENCY_CONCURRENT_REQUEST';
+const ERROR_CODE_IDEMPOTENCY_KEY_ALREADY_USED = 'IDEMPOTENCY_KEY_ALREADY_USED';
+const ERROR_CODE_IDEMPOTENCY_BACKEND_OPERATION_ERROR = 'IDEMPOTENCY_BACKEND_OPERATION_ERROR';
+/**
+ * Get the retry after in milliseconds from the response headers, undefined if not specified.
+ * The header could have two different format.
+ * Retry-After: <http-date>, like Wed, 21 Oct 2015 07:28:00 GMT
+ * Retry-After: <delay-seconds>, like 1.5s
+ * @param headers http headers
+ * @returns the time to delat in millisconds.
+ */
+function getRetryAfterInMs(headers) {
+    const retryAfterHeader = headers && headers[HTTP_HEADER_RETRY_AFTER];
+    if (retryAfterHeader === undefined) {
+        return undefined;
+    }
+    const delayInSecond = parseFloat(retryAfterHeader);
+    if (retryAfterHeader === delayInSecond.toString()) {
+        return Math.round(delayInSecond * 1000);
+    }
+    const delayUntilDateTime = Date.parse(retryAfterHeader);
+    if (isNaN(delayUntilDateTime)) {
+        return undefined;
+    }
+    return delayUntilDateTime - Date.now();
+}
+
+const DEFAULT_FIELD_LAST_MODIFIED_DATE$1 = 'LastModifiedDate';
+const DEFAULT_FIELD_CREATED_DATE$1 = 'CreatedDate';
+class AbstractResourceRequestActionHandler {
+    constructor(draftQueue, networkAdapter, getLuvio) {
+        this.draftQueue = draftQueue;
+        this.networkAdapter = networkAdapter;
+        this.getLuvio = getLuvio;
+        // NOTE[W-12567340]: This property stores in-memory mappings between draft
+        // ids and canonical ids for the current session. Having a local copy of
+        // these mappings is necessary to avoid a race condition between publishing
+        // new mappings to the durable store and those mappings being loaded into
+        // the luvio store redirect table, during which a new draft might be enqueued
+        // which would not see a necessary mapping.
+        this.ephemeralRedirects = {};
+        // determined by Server setup.
+        this.isIdempotencySupported = true;
+        // idempotency write flag set by lds
+        this.isLdsIdempotencyWriteDisabled = ldsIdempotencyWriteDisabled.isOpen({
+            fallback: false,
+        });
+        this.isBackdatingEnabled = ldsBackdatingEnabled.isOpen({ fallback: false });
+    }
+    enqueue(data) {
+        return this.draftQueue.enqueue(this.handlerId, data);
+    }
+    async handleAction(action, actionCompleted, actionErrored) {
+        const { data: request } = action;
+        // no context is stored in draft action
+        try {
+            const response = await this.networkAdapter(request, {});
+            if (response.ok) {
+                await actionCompleted({
+                    ...action,
+                    response,
+                    status: DraftActionStatus.Completed,
+                });
+                return ProcessActionResult.ACTION_SUCCEEDED;
+            }
+            let shouldRetry = false;
+            let retryDelayInMs = undefined;
+            let actionDataChanged = false;
+            let updatedAction = action;
+            if (request && request.headers && request.headers[HTTP_HEADER_IDEMPOTENCY_KEY]) {
+                const status = response.status;
+                switch (status) {
+                    case 408 /* IdempotentWriteSpecificHttpStatusCode.RequestTimeout */:
+                    case 503 /* IdempotentWriteSpecificHttpStatusCode.ServiceUnavailable */:
+                        retryDelayInMs = getRetryAfterInMs(response.headers);
+                        shouldRetry = true;
+                        break;
+                    case HttpStatusCode.ServerError: {
+                        shouldRetry = true;
+                        if (this.handleIdempotencyServerError(response.body, updatedAction, false, ERROR_CODE_IDEMPOTENCY_BACKEND_OPERATION_ERROR)) {
+                            this.isIdempotencySupported = false;
+                            retryDelayInMs = 0;
+                            actionDataChanged = true;
+                        }
+                        break;
+                    }
+                    case 409 /* IdempotentWriteSpecificHttpStatusCode.Conflict */: {
+                        if (this.isUiApiErrors(response.body)) {
+                            const errorCode = response.body[0].errorCode;
+                            if (this.handleIdempotencyServerError(response.body, updatedAction, true, ERROR_CODE_IDEMPOTENCY_KEY_USED_DIFFERENT_USER)) {
+                                retryDelayInMs = 0;
+                                actionDataChanged = true;
+                            }
+                            else if (errorCode === ERROR_CODE_IDEMPOTENCY_CONCURRENT_REQUEST) {
+                                retryDelayInMs = getRetryAfterInMs(response.headers);
+                            }
+                            shouldRetry = true;
+                        }
+                        break;
+                    }
+                    case HttpStatusCode.BadRequest: {
+                        if (this.handleIdempotencyServerError(response.body, updatedAction, false, ERROR_CODE_IDEMPOTENCY_FEATURE_NOT_ENABLED, ERROR_CODE_IDEMPOTENCY_NOT_SUPPORTED)) {
+                            retryDelayInMs = 0;
+                            actionDataChanged = true;
+                            shouldRetry = true;
+                        }
+                        break;
+                    }
+                    case 422 /* IdempotentWriteSpecificHttpStatusCode.UnProcessableEntity */: {
+                        if (this.handleIdempotencyServerError(response.body, updatedAction, true, ERROR_CODE_IDEMPOTENCY_KEY_ALREADY_USED)) {
+                            retryDelayInMs = 0;
+                            actionDataChanged = true;
+                            shouldRetry = true;
+                        }
+                        break;
+                    }
+                }
+            }
+            if (this.isBackdatingEnabled &&
+                response.status === HttpStatusCode.BadRequest &&
+                this.isBackdatingError(response.body, action)) {
+                updatedAction.timestamp = Date.now();
+                updatedAction.data.body.fields = {
+                    ...updatedAction.data.body.fields,
+                    LastModifiedDate: new Date(updatedAction.timestamp).toISOString(),
+                };
+                if (this.hasIdempotencySupport() &&
+                    updatedAction.data.headers[HTTP_HEADER_IDEMPOTENCY_KEY]) {
+                    updatedAction.data.headers[HTTP_HEADER_IDEMPOTENCY_KEY] = uuidv4();
+                }
+                shouldRetry = true;
+                actionDataChanged = true;
+            }
+            await actionErrored(shouldRetry
+                ? updatedAction
+                : {
+                    ...updatedAction,
+                    error: response,
+                    status: DraftActionStatus.Error,
+                }, shouldRetry, retryDelayInMs, actionDataChanged);
+            return ProcessActionResult.ACTION_ERRORED;
+        }
+        catch (e) {
+            await actionErrored(action, true);
+            return ProcessActionResult.NETWORK_ERROR;
+        }
+    }
+    // true if response is an idempotency server error. updates or deletes idempotency key if the reponse is idempotency related error. Idempotency related error is in format of UiApiError array.
+    handleIdempotencyServerError(responseBody, action, updateIdempotencyKey, ...targetErrorCodes) {
+        if (this.isUiApiErrors(responseBody)) {
+            const errorCode = responseBody[0].errorCode;
+            if (targetErrorCodes.includes(errorCode)) {
+                action.data.headers = action.data.headers || {};
+                if (updateIdempotencyKey) {
+                    action.data.headers[HTTP_HEADER_IDEMPOTENCY_KEY] = uuidv4();
+                }
+                else {
+                    delete action.data.headers[HTTP_HEADER_IDEMPOTENCY_KEY];
+                }
+                return true;
+            }
+        }
+        return false;
+    }
+    // checks if the body is an array of UiApiError. Sometimes the body has `enhancedErrorType` field as an error indicator(one example is the field validation failure). In such case Action being processed updates to an Error Action.
+    isUiApiErrors(body) {
+        return body !== undefined && isArray$3(body) && body.length > 0 && body[0].errorCode;
+    }
+    isBackdatingError(body, action) {
+        if (body.enhancedErrorType &&
+            body.enhancedErrorType === 'RecordError' &&
+            body.output &&
+            body.output.errors &&
+            isArray$3(body.output.errors) &&
+            body.output.errors.length > 0 &&
+            action.data.body &&
+            action.data.body.fields &&
+            action.data.body.fields[DEFAULT_FIELD_LAST_MODIFIED_DATE$1]) {
+            return body.output.errors.some((error) => error.errorCode === 'CollisionDetectedException');
+        }
+        return false;
+    }
+    async buildPendingAction(request, queue) {
+        const targetId = await this.getIdFromRequest(request);
+        const tag = this.buildTagForTargetId(targetId);
+        const handlerActions = queue.filter((x) => x.handler === this.handlerId);
+        if (request.method === 'post' && actionsForTag(tag, handlerActions).length > 0) {
+            return Promise.reject(new Error('Cannot enqueue a POST draft action with an existing tag'));
+        }
+        if (deleteActionsForTag(tag, handlerActions).length > 0) {
+            return Promise.reject(new Error('Cannot enqueue a draft action for a deleted record'));
+        }
+        return {
+            handler: this.handlerId,
+            targetId,
+            tag,
+            data: request,
+            status: DraftActionStatus.Pending,
+            id: generateUniqueDraftActionId(queue.map((x) => x.id)),
+            timestamp: Date.now(),
+            metadata: {},
+            version: '242.0.0',
+        };
+    }
+    async handleActionEnqueued(_action) { }
+    handleActionRemoved(action) {
+        return this.reingestRecord(action);
+    }
+    getQueueOperationsForCompletingDrafts(queue, action) {
+        const queueOperations = [];
+        const redirects = this.getRedirectMappings(action);
+        if (redirects !== undefined) {
+            const { length } = queue;
+            for (let i = 0; i < length; i++) {
+                const queueAction = queue[i];
+                // if this queueAction is the action that is completing we can move on,
+                // it is about to be deleted and won't have the draft ID in it
+                if (queueAction.id === action.id) {
+                    continue;
+                }
+                if (isResourceRequestAction(queueAction)) {
+                    let queueOperationMutated = false;
+                    let updatedActionTag = undefined;
+                    let updatedActionTargetId = undefined;
+                    const { tag: queueActionTag, data: queueActionRequest, id: queueActionId, } = queueAction;
+                    let { basePath, body } = queueActionRequest;
+                    let stringifiedBody = stringify$4(body);
+                    // for each redirected ID/key we loop over the operation to see if it needs
+                    // to be updated
+                    for (const { draftId, draftKey, canonicalId, canonicalKey } of redirects) {
+                        if (basePath.search(draftId) >= 0 || stringifiedBody.search(draftId) >= 0) {
+                            basePath = basePath.replace(draftId, canonicalId);
+                            stringifiedBody = stringifiedBody.replace(draftId, canonicalId);
+                            queueOperationMutated = true;
+                        }
+                        // if the action is performed on a previous draft id, we need to replace the action
+                        // with a new one at the updated canonical key
+                        if (queueActionTag === draftKey) {
+                            updatedActionTag = canonicalKey;
+                            updatedActionTargetId = canonicalId;
+                        }
+                    }
+                    if (queueOperationMutated) {
+                        if (updatedActionTag !== undefined && updatedActionTargetId !== undefined) {
+                            const updatedAction = {
+                                ...queueAction,
+                                tag: updatedActionTag,
+                                targetId: updatedActionTargetId,
+                                data: {
+                                    ...queueActionRequest,
+                                    basePath: basePath,
+                                    body: parse$4(stringifiedBody),
+                                },
+                            };
+                            // item needs to be replaced with a new item at the new record key
+                            queueOperations.push({
+                                type: QueueOperationType.Delete,
+                                id: queueActionId,
+                            });
+                            queueOperations.push({
+                                type: QueueOperationType.Add,
+                                action: updatedAction,
+                            });
+                        }
+                        else {
+                            const updatedAction = {
+                                ...queueAction,
+                                data: {
+                                    ...queueActionRequest,
+                                    basePath: basePath,
+                                    body: parse$4(stringifiedBody),
+                                },
+                            };
+                            // item needs to be updated
+                            queueOperations.push({
+                                type: QueueOperationType.Update,
+                                id: queueActionId,
+                                action: updatedAction,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        // delete completed action
+        queueOperations.push({
+            type: QueueOperationType.Delete,
+            id: action.id,
+        });
+        return queueOperations;
+    }
+    getRedirectMappings(action) {
+        if (action.data.method !== 'post') {
+            return undefined;
+        }
+        const body = action.response.body;
+        const canonicalId = this.getIdFromResponseBody(body);
+        const draftId = action.targetId;
+        if (draftId !== undefined && canonicalId !== undefined && draftId !== canonicalId) {
+            this.ephemeralRedirects[draftId] = canonicalId;
+        }
+        return [
+            {
+                draftId,
+                canonicalId,
+                draftKey: this.buildTagForTargetId(draftId),
+                canonicalKey: this.buildTagForTargetId(canonicalId),
+            },
+        ];
+    }
+    async handleActionCompleted(action, queueOperations, allHandlers) {
+        const { data: request, tag } = action;
+        const { method } = request;
+        if (method === 'delete') {
+            return this.evictKey(tag);
+        }
+        const recordsToIngest = [];
+        recordsToIngest.push({
+            response: action.response.body,
+            synchronousIngest: this.synchronousIngest.bind(this),
+            buildCacheKeysForResponse: this.buildCacheKeysFromResponse.bind(this),
+        });
+        const recordsNeedingReplay = queueOperations.filter((x) => x.type === QueueOperationType.Update);
+        for (const recordNeedingReplay of recordsNeedingReplay) {
+            const { action } = recordNeedingReplay;
+            if (isResourceRequestAction(action)) {
+                // We can't assume the queue operation is for our handler, have to find the handler.
+                const handler = allHandlers.find((h) => h.handlerId === action.handler);
+                if (handler !== undefined) {
+                    const record = await handler.getDataForAction(action);
+                    if (record !== undefined) {
+                        recordsToIngest.push({
+                            response: record,
+                            synchronousIngest: handler.synchronousIngest.bind(handler),
+                            buildCacheKeysForResponse: handler.buildCacheKeysFromResponse.bind(handler),
+                        });
+                    }
+                }
+            }
+        }
+        await this.ingestResponses(recordsToIngest, action);
+    }
+    handleReplaceAction(targetAction, sourceAction) {
+        //reject if the action to replace is a POST action
+        const pendingAction = targetAction;
+        if (pendingAction.data.method === 'post') {
+            throw Error('Cannot replace a POST action');
+        }
+        if (this.isActionOfType(targetAction) &&
+            this.isActionOfType(sourceAction)) {
+            targetAction.status = DraftActionStatus.Pending;
+            targetAction.data = sourceAction.data;
+            return targetAction;
+        }
+        else {
+            throw Error('Incompatible Action types to replace one another');
+        }
+    }
+    mergeActions(targetAction, sourceAction) {
+        const { id: targetId, data: targetData, metadata: targetMetadata, timestamp: targetTimestamp, } = targetAction;
+        const { method: targetMethod, body: targetBody } = targetData;
+        const { data: sourceData, metadata: sourceMetadata } = sourceAction;
+        const { method: sourceMethod, body: sourceBody } = sourceData;
+        if (targetMethod.toLowerCase() === 'delete' || sourceMethod.toLowerCase() === 'delete') {
+            throw Error('Cannot merge DELETE actions.');
+        }
+        if (targetMethod.toLowerCase() === 'patch' && sourceMethod.toLowerCase() === 'post') {
+            // overlaying a POST over a PATCH is not supported
+            throw Error('Cannot merge a POST action over top of a PATCH action.');
+        }
+        // overlay top-level properties, maintain target's timestamp and id
+        const merged = {
+            ...targetAction,
+            ...sourceAction,
+            timestamp: targetTimestamp,
+            id: targetId,
+        };
+        // overlay data
+        // NOTE: we stick to the target's ResourceRequest properties (except body
+        // which is merged) because we don't want to overwrite a POST with a PATCH
+        // (all other cases should be fine or wouldn't have passed pre-requisites)
+        merged.data = {
+            ...targetData,
+            body: this.mergeRequestBody(targetBody, sourceBody),
+        };
+        // Updates Idempotency key if target has one
+        if (targetData.headers && targetData.headers[HTTP_HEADER_IDEMPOTENCY_KEY]) {
+            merged.data.headers[HTTP_HEADER_IDEMPOTENCY_KEY] = uuidv4();
+        }
+        // overlay metadata
+        merged.metadata = { ...targetMetadata, ...sourceMetadata };
+        // put status back to pending to auto upload if queue is active and targed is at the head.
+        merged.status = DraftActionStatus.Pending;
+        return merged;
+    }
+    shouldDeleteActionByTagOnRemoval(action) {
+        return action.data.method === 'post';
+    }
+    updateMetadata(_existingMetadata, incomingMetadata) {
+        return incomingMetadata;
+    }
+    isActionOfType(action) {
+        return action.handler === this.handlerId;
+    }
+    async reingestRecord(action) {
+        const record = await this.getDataForAction(action);
+        if (record !== undefined) {
+            await this.ingestResponses([
+                {
+                    response: record,
+                    synchronousIngest: this.synchronousIngest.bind(this),
+                    buildCacheKeysForResponse: this.buildCacheKeysFromResponse.bind(this),
+                },
+            ], action);
+        }
+        else {
+            await this.evictKey(action.tag);
+        }
+    }
+    // Given an action for this handler this method should return the draft IDs.
+    // Most of the time it will simply be the targetId, but certain handlers might
+    // have multiple draft-created IDs so they would override this to return them.
+    getDraftIdsFromAction(action) {
+        return [action.targetId];
+    }
+    hasIdempotencySupport() {
+        return this.isIdempotencySupported && !this.isLdsIdempotencyWriteDisabled;
+    }
+    async ingestResponses(responses, action) {
+        const luvio = this.getLuvio();
+        await luvio.handleSuccessResponse(() => {
+            if (action.status === DraftActionStatus.Completed) {
+                const mappings = this.getRedirectMappings(action);
+                if (mappings) {
+                    mappings.forEach((mapping) => {
+                        luvio.storeRedirect(mapping.draftKey, mapping.canonicalKey);
+                    });
+                }
+            }
+            for (const entry of responses) {
+                const { response, synchronousIngest } = entry;
+                synchronousIngest(response, action);
+            }
+            return luvio.storeBroadcast();
+        }, 
+        // getTypeCacheKeysRecord uses the response, not the full path factory
+        // so 2nd parameter will be unused
+        () => {
+            const keySet = new StoreKeyMap();
+            for (const entry of responses) {
+                const { response, buildCacheKeysForResponse } = entry;
+                const set = buildCacheKeysForResponse(response);
+                for (const key of set.keys()) {
+                    const value = set.get(key);
+                    if (value !== undefined) {
+                        keySet.set(key, value);
+                    }
+                }
+            }
+            return keySet;
+        });
+    }
+    async evictKey(key) {
+        const luvio = this.getLuvio();
+        await luvio.handleSuccessResponse(() => {
+            luvio.storeEvict(key);
+            return luvio.storeBroadcast();
+        }, () => {
+            return new StoreKeyMap();
+        });
+    }
+}
+function actionsForTag(tag, queue) {
+    return queue.filter((action) => action.tag === tag);
+}
+function deleteActionsForTag(tag, queue) {
+    return queue.filter((action) => action.tag === tag && action.data.method === 'delete');
+}
+function isResourceRequestAction(action) {
+    const dataAsAny = action.data;
+    return (dataAsAny !== undefined && dataAsAny.method !== undefined && dataAsAny.body !== undefined);
+}
+
 function clone(obj) {
     return parse$5(stringify$5(obj));
 }
@@ -5274,12 +5272,12 @@ function buildAdapterValidationConfig(displayName, paramsMeta) {
 }
 const keyPrefix = 'UiApi';
 
-const { assign: assign$5, create: create$5, freeze: freeze$1, isFrozen, keys: keys$5 } = Object;
+const { assign: assign$4, create: create$4, freeze: freeze$1, isFrozen, keys: keys$4 } = Object;
 const { hasOwnProperty } = Object.prototype;
 const { split, endsWith } = String.prototype;
 const { isArray: isArray$2 } = Array;
-const { concat, filter, includes, push: push$2, reduce } = Array.prototype;
-const { parse: parse$4, stringify: stringify$4 } = JSON;
+const { concat, filter, includes, push: push$1, reduce } = Array.prototype;
+const { parse: parse$3, stringify: stringify$3 } = JSON;
 
 function isString(value) {
     return typeof value === 'string';
@@ -5303,7 +5301,7 @@ function dedupe(value) {
     for (let i = 0, len = value.length; i < len; i += 1) {
         result[value[i]] = true;
     }
-    return keys$5(result);
+    return keys$4(result);
 }
 /**
  * @param source The array of string to filter
@@ -5447,7 +5445,7 @@ function getFieldApiNamesArray(value, options = { onlyQualifiedFieldNames: false
             }
             return undefined;
         }
-        push$2.call(array, apiName);
+        push$1.call(array, apiName);
     }
     if (array.length === 0) {
         return undefined;
@@ -6902,14 +6900,14 @@ const getTypeCacheKeys$1u = (rootKeySet, luvio, input, _fullPathFactory) => {
         mergeable: true,
     });
     const input_childRelationships = input.childRelationships;
-    const input_childRelationships_keys = keys$5(input_childRelationships);
+    const input_childRelationships_keys = keys$4(input_childRelationships);
     const input_childRelationships_length = input_childRelationships_keys.length;
     for (let i = 0; i < input_childRelationships_length; i++) {
         const key = input_childRelationships_keys[i];
         getTypeCacheKeys$1t(rootKeySet, luvio, input_childRelationships[key], () => rootKey + '__childRelationships' + '__' + key);
     }
     const input_fields = input.fields;
-    const field_values = keys$5(input_fields);
+    const field_values = keys$4(input_fields);
     const input_fields_length = field_values.length;
     for (let i = 0; i < input_fields_length; i++) {
         const field_value = input_fields[field_values[i]];
@@ -7365,7 +7363,7 @@ function convertRecordFieldsArrayToTrie(fields, optionalFields = []) {
 function createPathSelection(propertyName, fieldDefinition) {
     const fieldsSelection = [];
     const { children } = fieldDefinition;
-    const childrenKeys = keys$5(children);
+    const childrenKeys = keys$4(children);
     for (let i = 0, len = childrenKeys.length; i < len; i += 1) {
         const childKey = childrenKeys[i];
         const childFieldDefinition = children[childKey];
@@ -7403,7 +7401,7 @@ function createPathSelection(propertyName, fieldDefinition) {
                 ],
             };
         }
-        push$2.call(fieldsSelection, fieldSelection);
+        push$1.call(fieldsSelection, fieldSelection);
     }
     return {
         kind: 'Object',
@@ -7416,7 +7414,7 @@ function createPathSelection(propertyName, fieldDefinition) {
  */
 function createPathSelectionFromValue(fields) {
     const fieldsSelections = [];
-    const fieldNames = keys$5(fields);
+    const fieldNames = keys$4(fields);
     for (let i = 0, len = fieldNames.length; i < len; i++) {
         const fieldName = fieldNames[i];
         const { value: fieldValue } = fields[fieldName];
@@ -7451,7 +7449,7 @@ function createPathSelectionFromValue(fields) {
                 selections: [DISPLAY_VALUE_SELECTION, SCALAR_VALUE_SELECTION],
             };
         }
-        push$2.call(fieldsSelections, fieldSelection);
+        push$1.call(fieldsSelections, fieldSelection);
     }
     return {
         kind: 'Object',
@@ -7461,7 +7459,7 @@ function createPathSelectionFromValue(fields) {
 }
 function extractRecordFieldsRecursively(record) {
     const fields = [];
-    const fieldNames = keys$5(record.fields);
+    const fieldNames = keys$4(record.fields);
     for (let i = 0, len = fieldNames.length; i < len; i++) {
         const fieldName = fieldNames[i];
         const { value: fieldValue } = record.fields[fieldName];
@@ -7470,10 +7468,10 @@ function extractRecordFieldsRecursively(record) {
             for (let j = 0, len = spanningRecordFields.length; j < len; j++) {
                 spanningRecordFields[j] = `${fieldName}.${spanningRecordFields[j]}`;
             }
-            push$2.apply(fields, spanningRecordFields);
+            push$1.apply(fields, spanningRecordFields);
         }
         else {
-            push$2.call(fields, fieldName);
+            push$1.call(fields, fieldName);
         }
     }
     return fields;
@@ -9420,7 +9418,7 @@ function mergePendingFields(newRecord, oldRecord) {
     // RecordRepresentationNormalized['fields'] to include `pending:true` property
     const mergedFields = { ...newRecord.fields };
     const merged = { ...newRecord, fields: mergedFields };
-    const existingFields = keys$5(oldRecord.fields);
+    const existingFields = keys$4(oldRecord.fields);
     for (let i = 0, len = existingFields.length; i < len; i += 1) {
         const spanningFieldName = existingFields[i];
         if (newRecord.fields[spanningFieldName] === undefined) {
@@ -9543,7 +9541,7 @@ function merge$1(existing, incoming, luvio, _path, recordConflictMap) {
         if (isGraphNode(node)) {
             const dependencies = node.retrieve();
             if (dependencies !== null) {
-                const depKeys = keys$5(dependencies);
+                const depKeys = keys$4(dependencies);
                 for (let i = 0, len = depKeys.length; i < len; i++) {
                     luvio.storeEvict(depKeys[i]);
                 }
@@ -9701,14 +9699,14 @@ fieldNode) {
     let fields = [];
     const fieldSubtries = [];
     if (fieldsTrie) {
-        push$2.call(fieldSubtries, fieldsTrie);
+        push$1.call(fieldSubtries, fieldsTrie);
     }
     if (optionalFieldsTrie) {
-        push$2.call(fieldSubtries, optionalFieldsTrie);
+        push$1.call(fieldSubtries, optionalFieldsTrie);
     }
     for (let i = 0; i < fieldSubtries.length; i++) {
         const subtrie = fieldSubtries[i];
-        const fieldNames = keys$5(subtrie.children);
+        const fieldNames = keys$4(subtrie.children);
         for (let i = 0; i < fieldNames.length; i++) {
             const fieldName = fieldNames[i];
             const childTrie = subtrie.children[fieldName];
@@ -9832,13 +9830,13 @@ function isExternalLookupFieldKey(spanningNode) {
     return endsWith.call(spanningNode.scalar('apiName'), CUSTOM_EXTERNAL_OBJECT_FIELD_SUFFIX);
 }
 function convertTrieToFields(root) {
-    if (keys$5(root.children).length === 0) {
+    if (keys$4(root.children).length === 0) {
         return [];
     }
     return convertTrieToFieldsRecursively(root);
 }
 function convertTrieToFieldsRecursively(root) {
-    const childKeys = keys$5(root.children);
+    const childKeys = keys$4(root.children);
     if (childKeys.length === 0) {
         if (root.name === '') {
             return [];
@@ -9875,7 +9873,7 @@ const getObjectNameFromField = (field) => {
 function mergeFieldsTries(rootA, rootB) {
     const rootAchildren = rootA.children;
     const rootBchildren = rootB.children;
-    const childBKeys = keys$5(rootBchildren);
+    const childBKeys = keys$4(rootBchildren);
     for (let i = 0, len = childBKeys.length; i < len; i++) {
         const childBKey = childBKeys[i];
         if (rootAchildren[childBKey] === undefined) {
@@ -10042,8 +10040,8 @@ function isSuperRecordFieldTrie(a, b) {
     }
     const childrenA = a.children;
     const childrenB = b.children;
-    const childKeysA = keys$5(childrenA);
-    const childKeysB = keys$5(childrenB);
+    const childKeysA = keys$4(childrenA);
+    const childKeysB = keys$4(childrenB);
     const childKeysBLength = childKeysB.length;
     if (childKeysBLength > childKeysA.length) {
         return false;
@@ -10097,9 +10095,9 @@ function fulfill(existing, incoming) {
             return false;
         }
     }
-    const headersKeys = keys$5(headers);
+    const headersKeys = keys$4(headers);
     const headersKeyLength = headersKeys.length;
-    if (headersKeyLength !== keys$5(existingHeaders).length) {
+    if (headersKeyLength !== keys$4(existingHeaders).length) {
         return false;
     }
     for (let i = 0, len = headersKeyLength; i < len; i++) {
@@ -10728,7 +10726,7 @@ function buildNetworkSnapshot$h(luvio, config, serverRequestCount = 0, options)
 
 // iterate through the map to build configs for network calls
 function resolveConflict(luvio, map) {
-    const ids = keys$5(map.conflicts);
+    const ids = keys$4(map.conflicts);
     if (ids.length === 0) {
         instrumentation.recordConflictsResolved(map.serverRequestCount);
         return;
@@ -10744,7 +10742,7 @@ function resolveConflict(luvio, map) {
     else {
         const records = reduce.call(ids, (acc, id) => {
             const { trackedFields } = map.conflicts[id];
-            push$2.call(acc, {
+            push$1.call(acc, {
                 recordIds: [id],
                 optionalFields: convertTrieToFields(trackedFields),
             });
@@ -12175,18 +12173,18 @@ function listFields(luvio, { fields = [], optionalFields = [], sortBy, }, listIn
     return {
         getRecordSelectionFieldSets() {
             const optionalPlusDefaultFields = { ...optionalFields_ };
-            const fields = keys$5(defaultFields_);
+            const fields = keys$4(defaultFields_);
             for (let i = 0; i < fields.length; ++i) {
                 const field = fields[i];
                 if (!fields_[field] && !defaultServerFieldStatus.missingFields[field]) {
                     optionalPlusDefaultFields[field] = true;
                 }
             }
-            return [keys$5(fields_).sort(), keys$5(optionalPlusDefaultFields).sort()];
+            return [keys$4(fields_).sort(), keys$4(optionalPlusDefaultFields).sort()];
         },
         processRecords(records) {
             const { missingFields } = defaultServerFieldStatus;
-            const fields = keys$5(missingFields);
+            const fields = keys$4(missingFields);
             for (let i = 0; i < fields.length; ++i) {
                 const field = fields[i], splitField = field.split('.').slice(1);
                 for (let i = 0; i < records.length; ++i) {
@@ -15666,7 +15664,7 @@ function getRecordId18Array(value) {
         if (apiName === undefined) {
             return undefined;
         }
-        push$2.call(array, apiName);
+        push$1.call(array, apiName);
     }
     if (array.length === 0) {
         return undefined;
@@ -16142,15 +16140,15 @@ function buildRecordUiSelector(recordDefs, layoutTypes, modes, recordOptionalFie
                 name: mode,
                 fragment: layoutSelections$2,
             };
-            push$2.call(modeSelections, modeSel);
+            push$1.call(modeSelections, modeSel);
         }
-        push$2.call(layoutTypeSelections, sel);
+        push$1.call(layoutTypeSelections, sel);
     }
     const recordLayoutSelections = [];
     const recordSelections = [];
     for (let i = 0, len = recordDefs.length; i < len; i += 1) {
         const { recordId, recordData } = recordDefs[i];
-        push$2.call(recordLayoutSelections, {
+        push$1.call(recordLayoutSelections, {
             kind: 'Object',
             name: recordData.apiName,
             required: false,
@@ -16159,7 +16157,7 @@ function buildRecordUiSelector(recordDefs, layoutTypes, modes, recordOptionalFie
         });
         const optionalFields = recordOptionalFields[recordId];
         const fields = extractFields(recordData);
-        push$2.call(recordSelections, {
+        push$1.call(recordSelections, {
             kind: 'Link',
             name: recordId,
             fragment: {
@@ -16281,7 +16279,7 @@ function getMissingRecordLookupFields(record, objectInfo) {
     const lookupFields = {};
     const { apiName, fields: recordFields } = record;
     const { fields: objectInfoFields } = objectInfo;
-    const objectInfoFieldNames = keys$5(objectInfoFields);
+    const objectInfoFieldNames = keys$4(objectInfoFields);
     for (let i = 0, len = objectInfoFieldNames.length; i < len; i += 1) {
         const fieldName = objectInfoFieldNames[i];
         const field = objectInfoFields[fieldName];
@@ -16300,12 +16298,12 @@ function getMissingRecordLookupFields(record, objectInfo) {
         const nameField = `${apiName}.${relationshipName}.${getNameField(objectInfo, fieldName)}`;
         lookupFields[nameField] = true;
     }
-    return keys$5(lookupFields);
+    return keys$4(lookupFields);
 }
 function getRecordUiMissingRecordLookupFields(recordUi) {
     const { records, objectInfos } = recordUi;
     const recordLookupFields = {};
-    const recordIds = keys$5(records);
+    const recordIds = keys$4(records);
     for (let i = 0, len = recordIds.length; i < len; i += 1) {
         const recordId = recordIds[i];
         const recordData = records[recordId];
@@ -16343,19 +16341,19 @@ function buildCachedSelectorKey(key) {
 }
 function eachLayout(recordUi, cb) {
     const { layouts } = recordUi;
-    const layoutApiNames = keys$5(layouts);
+    const layoutApiNames = keys$4(layouts);
     for (let a = 0, len = layoutApiNames.length; a < len; a += 1) {
         const apiName = layoutApiNames[a];
         const apiNameData = layouts[apiName];
-        const recordTypeIds = keys$5(apiNameData);
+        const recordTypeIds = keys$4(apiNameData);
         for (let b = 0, recordTypeIdsLen = recordTypeIds.length; b < recordTypeIdsLen; b += 1) {
             const recordTypeId = recordTypeIds[b];
             const recordTypeData = apiNameData[recordTypeId];
-            const layoutTypes = keys$5(recordTypeData);
+            const layoutTypes = keys$4(recordTypeData);
             for (let c = 0, layoutTypesLen = layoutTypes.length; c < layoutTypesLen; c += 1) {
                 const layoutType = layoutTypes[c];
                 const layoutTypeData = recordTypeData[layoutType];
-                const modes = keys$5(layoutTypeData);
+                const modes = keys$4(layoutTypeData);
                 for (let d = 0, modesLen = modes.length; d < modesLen; d += 1) {
                     const mode = modes[d];
                     const layout = layoutTypeData[mode];
@@ -16370,7 +16368,7 @@ function collectRecordDefs(resp, recordIds) {
     for (let i = 0, len = recordIds.length; i < len; i += 1) {
         const recordId = recordIds[i];
         const recordData = resp.records[recordId];
-        push$2.call(recordDefs, {
+        push$1.call(recordDefs, {
             recordId,
             recordData,
             recordTypeId: getRecordTypeId$2(recordData),
@@ -16431,7 +16429,7 @@ function prepareRequest$3(luvio, config) {
 // we have to run ingest code and look at the resulting snapshot's seenRecords.
 function getCacheKeys(keySet, luvio, config, key, originalResponseBody) {
     const { recordIds, layoutTypes, modes } = config;
-    const responseBody = parse$4(stringify$4(originalResponseBody));
+    const responseBody = parse$3(stringify$3(originalResponseBody));
     eachLayout(responseBody, (apiName, recordTypeId, layout) => {
         if (layout.id === null) {
             return;
@@ -16561,14 +16559,14 @@ function buildNetworkSnapshot$e(luvio, config, dispatchContext) {
 function publishDependencies(luvio, recordIds, depKeys) {
     for (let i = 0, len = recordIds.length; i < len; i += 1) {
         const recordDepKey = dependencyKeyBuilder({ recordId: recordIds[i] });
-        const dependencies = create$5(null);
+        const dependencies = create$4(null);
         for (let j = 0, len = depKeys.length; j < len; j++) {
             dependencies[depKeys[j]] = true;
         }
         const node = luvio.getNode(recordDepKey);
         if (isGraphNode(node)) {
             const recordDeps = node.retrieve();
-            assign$5(dependencies, recordDeps);
+            assign$4(dependencies, recordDeps);
         }
         luvio.storePublish(recordDepKey, dependencies);
     }
@@ -16686,7 +16684,7 @@ function refresh(luvio, config) {
         }
         if (isUnfulfilledSnapshot$1(snapshot)) {
             if (process.env.NODE_ENV !== 'production') {
-                throw new Error(`RecordUi adapter resolved with a snapshot with missing data, missingPaths: ${keys$5(snapshot.missingPaths)}`);
+                throw new Error(`RecordUi adapter resolved with a snapshot with missing data, missingPaths: ${keys$4(snapshot.missingPaths)}`);
             }
         }
         const { data } = snapshot;
@@ -16733,7 +16731,7 @@ function processRecordUiRepresentation(luvio, refresh, recordId, modes, snapshot
     }
     if (isUnfulfilledSnapshot$1(snapshot)) {
         if (process.env.NODE_ENV !== 'production') {
-            throw new Error(`RecordUi adapter resolved with a snapshot with missing data, missingPaths: ${keys$5(snapshot.missingPaths)}`);
+            throw new Error(`RecordUi adapter resolved with a snapshot with missing data, missingPaths: ${keys$4(snapshot.missingPaths)}`);
         }
     }
     const { data } = snapshot;
@@ -16762,11 +16760,11 @@ const recordLayoutFragmentSelector = [
 function getFieldsFromLayoutMap(layoutMap, objectInfo) {
     let fields = [];
     let optionalFields = [];
-    const layoutTypes = keys$5(layoutMap);
+    const layoutTypes = keys$4(layoutMap);
     for (let i = 0, layoutTypesLen = layoutTypes.length; i < layoutTypesLen; i += 1) {
         const layoutType = layoutTypes[i];
         const modesMap = layoutMap[layoutType];
-        const modes = keys$5(modesMap);
+        const modes = keys$4(modesMap);
         for (let m = 0, modesLen = modes.length; m < modesLen; m += 1) {
             const mode = modes[m];
             const { fields: modeFields, optionalFields: modeOptionalFields } = getQualifiedFieldApiNamesFromLayout(modesMap[mode], objectInfo);
@@ -16802,7 +16800,7 @@ function getRecordForLayoutableEntities(luvio, refresh, recordId, layoutMap, obj
     return getRecord(luvio, refresh, recordId, [], implicitFields);
 }
 function getRecordForNonLayoutableEntities(luvio, adapterContext, refresh, recordId, objectInfo, configOptionalFields, configFields) {
-    const fields = keys$5(configFields ? configFields : {}).map((key) => `${objectInfo.apiName}.${key}`);
+    const fields = keys$4(configFields ? configFields : {}).map((key) => `${objectInfo.apiName}.${key}`);
     // W-12697744
     // Set the implicit fields received from the server in adapter context
     // This ensures that the implicit fields are available when data is read locally or from durable store
@@ -17041,7 +17039,7 @@ function makeRecordLayoutMap(luvio, config, apiName, recordTypeId, layoutTypes,
             }
             const { layoutType, mode, snapshot } = container;
             if (wrapper.layoutMap[layoutType] === undefined) {
-                wrapper.layoutMap = assign$5({}, wrapper.layoutMap, {
+                wrapper.layoutMap = assign$4({}, wrapper.layoutMap, {
                     [layoutType]: {},
                 });
             }
@@ -17777,7 +17775,7 @@ function typeCheckConfig$9(untrustedConfig) {
             }
         }
         if (records.length > 0) {
-            assign$5(config, { records });
+            assign$4(config, { records });
         }
     }
     return config;
@@ -43578,8 +43576,8 @@ function isArrayLike(x) {
         (x.length === 0 || (x.length > 0 && Object.prototype.hasOwnProperty.call(x, x.length - 1))));
 }
 
-const { create: create$4, keys: keys$4, values: values$2, entries: entries$4, assign: assign$4 } = Object;
-const { stringify: stringify$3, parse: parse$3 } = JSON;
+const { create: create$3, keys: keys$3, values: values$2, entries: entries$3, assign: assign$3 } = Object;
+const { stringify: stringify$2, parse: parse$2 } = JSON;
 const { isArray: isArray$1, from: from$1 } = Array;
 
 function recordLoaderFactory(query) {
@@ -43591,7 +43589,7 @@ function recordLoaderFactory(query) {
             rows.forEach((row) => {
                 if (!row[0])
                     return null;
-                const record = parse$3(row[0]);
+                const record = parse$2(row[0]);
                 if (record.id === id) {
                     foundRow = record;
                 }
@@ -43950,11 +43948,11 @@ function dateTimePredicate(input, operator, field, alias) {
         return dateTimeRange(range, operator, field, alias);
     }
     // eslint-disable-next-line @salesforce/lds/no-error-in-production
-    throw new Error(`Where filter ${stringify$3(input)} is not supported`);
+    throw new Error(`Where filter ${stringify$2(input)} is not supported`);
 }
 function dateTimeRange(input, op, field, alias) {
     const dateFunction = field.dataType === 'DateTime' ? 'datetime' : 'date';
-    const key = keys$4(input)[0];
+    const key = keys$3(input)[0];
     let operator = op;
     if (operator === '=')
         operator = 'BETWEEN';
@@ -44254,7 +44252,7 @@ function filterToPredicates(where, recordType, alias, objectInfoMap, joins, draf
     if (!where)
         return [];
     let predicates = [];
-    const fields = keys$4(where);
+    const fields = keys$3(where);
     for (const field of fields) {
         if (field === 'and' || field === 'or') {
             predicates.push(processCompoundPredicate(field, where[field], recordType, alias, objectInfoMap, joins));
@@ -44279,8 +44277,12 @@ function filterToPredicates(where, recordType, alias, objectInfoMap, joins, draf
         // handles spanning field filter. For example, for 'OwnerId' field within 'Account' objectInfo, both 'OwnerId' and 'Owner' can be
         // treated as reference type, while 'Owner' field spanns since it equals to 'relationshipName'
         if (fieldInfo.dataType === 'Reference' && fieldInfo.relationshipName === field) {
+            let leftPath = `$.fields.${fieldInfo.apiName}.value`;
+            if (fieldInfo.apiName === 'RecordTypeId') {
+                leftPath = '$.recordTypeId';
+            }
             const path = {
-                leftPath: `$.fields.${fieldInfo.apiName}.value`,
+                leftPath: leftPath,
                 rightPath: `$.id`,
             };
             const childAlias = `${alias}_${field}`;
@@ -44303,7 +44305,7 @@ function filterToPredicates(where, recordType, alias, objectInfoMap, joins, draf
             }
             else {
                 // @W-12618378 polymorphic query sometimes does not work as expected on server. The GQL on certain entities could fail.
-                const entityNames = keys$4(where[field]);
+                const entityNames = keys$3(where[field]);
                 const polyPredicatesGroups = entityNames
                     .filter((entityName) => fieldInfo.referenceToInfos.some((referenceInfo) => referenceInfo.apiName === entityName))
                     .map((entityName) => {
@@ -44333,7 +44335,7 @@ function filterToPredicates(where, recordType, alias, objectInfoMap, joins, draf
         }
         else {
             //`field` match the filedInfo's apiName
-            for (const [op, value] of entries$4(where[field])) {
+            for (const [op, value] of entries$3(where[field])) {
                 const operator = operatorToSql(op);
                 /**
                 Two types ID processing might be needed. Draft ID swapping is optional, which depends on DraftFunctions existence.
@@ -45504,7 +45506,7 @@ function depth(json, currentLevel = 0) {
     if (typeof json !== 'object') {
         return currentLevel;
     }
-    const keys$1 = keys$4(json);
+    const keys$1 = keys$3(json);
     if (keys$1.length === 0)
         return 0;
     const depths = keys$1.map((key) => {
@@ -45557,7 +45559,7 @@ function orderByToPredicate(orderBy, recordType, alias, objectInfoMap, joins) {
         return predicates;
     const isSpanning = depth(orderBy) > 2;
     if (isSpanning) {
-        const keys$1 = keys$4(orderBy);
+        const keys$1 = keys$3(orderBy);
         for (let i = 0, len = keys$1.length; i < len; i++) {
             const key = keys$1[i];
             const parentFields = objectInfoMap[recordType].fields;
@@ -45587,7 +45589,7 @@ function orderByToPredicate(orderBy, recordType, alias, objectInfoMap, joins) {
         }
     }
     else {
-        const keys$1 = keys$4(orderBy);
+        const keys$1 = keys$3(orderBy);
         for (let i = 0, len = keys$1.length; i < len; i++) {
             const key = keys$1[i];
             if (!objectInfoMap[recordType])
@@ -45802,14 +45804,14 @@ function isLocalCursor(maybeCursor) {
         typeof maybeCursor.i === 'number');
 }
 function encodeV1Cursor(cursor) {
-    return base64encode(stringify$3(cursor));
+    return base64encode(stringify$2(cursor));
 }
 const CURSOR_PARSE_ERROR = 'Unable to parse cursor';
 function decodeV1Cursor(base64cursor) {
     let maybeCursor;
     try {
         const cursorString = base64decode(base64cursor);
-        maybeCursor = parse$3(cursorString);
+        maybeCursor = parse$2(cursorString);
     }
     catch (error) {
         let message = CURSOR_PARSE_ERROR;
@@ -46013,7 +46015,7 @@ async function readPaginationMetadataForKeys(keys, query) {
     const results = await query(sql, keys.map((k) => k + '__pagination'));
     for (let row of results.rows) {
         let key = row[0].replace(/__pagination$/, '');
-        let metadata = parse$3(row[1]);
+        let metadata = parse$2(row[1]);
         metadataMap.set(key, metadata);
     }
     return metadataMap;
@@ -46117,8 +46119,8 @@ async function connectionResolver(obj, args, context, info) {
     //map each sql result with the ingestion timestamp to pass it down a level
     let records = results.rows.map((row, index) => {
         const recordMetadataResult = {
-            recordRepresentation: parse$3(row[0]),
-            metadata: parse$3(row[1]),
+            recordRepresentation: parse$2(row[0]),
+            metadata: parse$2(row[1]),
         };
         const { recordRepresentation, metadata } = recordMetadataResult;
         context.seenRecordIds.add(recordRepresentation.id);
@@ -46191,7 +46193,7 @@ function buildKeyStringForRecordQuery(operation, variables, argumentNodes, curre
         variables,
         fragmentMap: {},
     });
-    const filteredArgumentNodes = assign$4([], argumentNodes).filter((node) => node.name.value !== 'first' && node.name.value !== 'after');
+    const filteredArgumentNodes = assign$3([], argumentNodes).filter((node) => node.name.value !== 'first' && node.name.value !== 'after');
     const argumentString = filteredArgumentNodes.length > 0
         ? '__' + serializeFieldArguments(filteredArgumentNodes, variables)
         : '';
@@ -46606,7 +46608,7 @@ function generateRecordQueries(schema, objectInfoMap) {
     // use a set to not allow duplicate scalars causing error(s)
     let addedTypedScalars = new Set();
     let allPolymorphicFieldTypeNames = new Set();
-    for (const name of keys$4(objectInfoMap)) {
+    for (const name of keys$3(objectInfoMap)) {
         const objectInfo = objectInfoMap[name];
         const { apiName } = objectInfo;
         const type = schema.getType(apiName);
@@ -46733,7 +46735,7 @@ function extendExistingRecordType(schema, type, objectInfo, objectInfoMap) {
     // use a set to not allow duplicate scalars causing error(s)
     let typedScalars = new Set();
     let parentRelationshipFields = new Set();
-    const existingFields = keys$4(type.getFields());
+    const existingFields = keys$3(type.getFields());
     const missingFields = values$2(objectInfo.fields).filter((field) => {
         return (existingFields.includes(field.apiName) === false ||
             (field.relationshipName !== null && field.referenceToInfos.length > 0));
@@ -47592,7 +47594,7 @@ async function resolveObjectInfos(objectInfotree, pathToObjectApiNamesMap, start
         // eslint-disable-next-line
         throw new Error(`Unable to resolve ObjectInfo(s) for ${Array.from(startNodes)}`);
     }
-    if (keys$4(objectInfos).length < startNodes.size) {
+    if (keys$3(objectInfos).length < startNodes.size) {
         // eslint-disable-next-line
         throw new Error(`Unable to resolve ObjectInfo(s) for ${Array.from(startNodes)}`);
     }
@@ -48533,7 +48535,7 @@ function removeSyntheticFields(result, query) {
     output.data.uiapi = { ...output.data.uiapi };
     output.data.uiapi.query = { ...output.data.uiapi.query };
     const outputApiParent = output.data.uiapi.query;
-    const keys$1 = keys$4(nodeJson);
+    const keys$1 = keys$3(nodeJson);
     keys$1.forEach((recordName) => {
         const outputApi = {};
         // Each connectionSelection's maps its name or alias to one of returned records. The record name could be `apiName' or alias
@@ -48553,7 +48555,7 @@ function removeSyntheticFields(result, query) {
  * @param jsonOutput JsonObject which will be populated with properties. It would only contains properties defined in 'FieldNode'
  */
 function createUserJsonOutput(selection, jsonInput, jsonOutput) {
-    const keys$1 = keys$4(jsonInput);
+    const keys$1 = keys$3(jsonInput);
     if (selection.selectionSet) {
         createjsonOutput(selection.selectionSet.selections, jsonInput, jsonOutput);
     }
@@ -48562,7 +48564,7 @@ function createUserJsonOutput(selection, jsonInput, jsonOutput) {
     }
 }
 function createjsonOutput(selections, jsonInput, jsonOutput) {
-    const keys$1 = keys$4(jsonInput);
+    const keys$1 = keys$3(jsonInput);
     selections.filter(isFieldNode).forEach((subSelection) => {
         const fieldName = subSelection.alias ? subSelection.alias.value : subSelection.name.value;
         if (keys$1.includes(fieldName)) {
@@ -48938,7 +48940,7 @@ const replaceDraftIdsInVariables = (variables, draftFunctions, unmappedDraftIDs)
         }
         else if (typeof object === 'object' && object !== null) {
             let source = object;
-            return keys$4(source).reduce((acc, key) => {
+            return keys$3(source).reduce((acc, key) => {
                 acc[key] = replace(source[key]);
                 return acc;
             }, {});
@@ -48947,7 +48949,7 @@ const replaceDraftIdsInVariables = (variables, draftFunctions, unmappedDraftIDs)
             return object;
         }
     };
-    let newVariables = keys$4(variables).reduce((acc, key) => {
+    let newVariables = keys$3(variables).reduce((acc, key) => {
         acc[key] = replace(variables[key]);
         return acc;
     }, {});
@@ -48959,7 +48961,7 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
     const getCanonicalId = getCanonicalIdFunction(luvio);
     return async function draftAwareGraphQLAdapter(config, requestContext = {}) {
         //create a copy to not accidentally modify the AST in the astResolver map of luvio
-        const copy = parse$3(stringify$3(config.query));
+        const copy = parse$2(stringify$2(config.query));
         // the injected ast has extra fields needed for eval in it
         let injectedAST;
         // the cursor mapped ast is passed upstream so it won't reject on our local cursors
@@ -49053,7 +49055,7 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
             } = await evaluate({
                 ...config,
                 //need to create another copy of the ast for future writes
-                query: parse$3(stringify$3(injectedAST)),
+                query: parse$2(stringify$2(injectedAST)),
             }, observers, { userId }, objectInfoNeeded, store, nonEvaluatedSnapshot, graphqlSchemaCache, draftFunctions, mappedCursors));
         }
         catch (throwable) {
@@ -49169,7 +49171,7 @@ function makeGetRecordsConfig(keyMap) {
 
 function environmentAwareGraphQLBatchAdapterFactory(objectInfoService, luvio, isDraftId, buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy) {
     return async function environmentAwareGraphQLBatchAdapter(config, requestContext = {}) {
-        const batchQueryCopy = config.batchQuery.map((query) => parse$3(stringify$3(query)));
+        const batchQueryCopy = config.batchQuery.map((query) => parse$2(stringify$2(query)));
         let injectedBatchQuery = [];
         const getCanonicalId = getCanonicalIdFunction(luvio);
         const draftFunctions = {
@@ -49393,14 +49395,14 @@ const recordIdGenerator = (id) => {
  */
 
 
-const { keys: keys$3, create: create$3, assign: assign$3, entries: entries$3 } = Object;
-const { stringify: stringify$2, parse: parse$2 } = JSON;
-const { push: push$1, join: join$1, slice: slice$1 } = Array.prototype;
+const { keys: keys$2, create: create$2, assign: assign$2, entries: entries$2 } = Object;
+const { stringify: stringify$1, parse: parse$1 } = JSON;
+const { push, join, slice } = Array.prototype;
 const { isArray, from } = Array;
 
 function ldsParamsToString(params) {
-    const returnParams = create$3(null);
-    const keys$1 = keys$3(params);
+    const returnParams = create$2(null);
+    const keys$1 = keys$2(params);
     for (let i = 0, len = keys$1.length; i < len; i++) {
         const key = keys$1[i];
         const value = params[key];
@@ -49417,8 +49419,8 @@ function ldsParamsToString(params) {
         else {
             returnParams[key] = `${value}`;
         }
-        if (isObject(value) === true && keys$3(value).length > 0) {
-            returnParams[key] = stringify$2(value);
+        if (isObject(value) === true && keys$2(value).length > 0) {
+            returnParams[key] = stringify$1(value);
         }
     }
     return returnParams;
@@ -49477,13 +49479,13 @@ function stringifyIfPresent(value) {
     if (value === undefined || value === null) {
         return null;
     }
-    return stringify$2(value);
+    return stringify$1(value);
 }
 function parseIfPresent(value) {
     if (value === undefined || value === null || value === '') {
         return null;
     }
-    return parse$2(value);
+    return parse$1(value);
 }
 function buildNimbusNetworkPluginRequest(resourceRequest, resourceRequestContext) {
     const { basePath, baseUri, method, headers, queryParams, body } = resourceRequest;
@@ -49574,10 +49576,10 @@ class ScopedFields {
         fields.forEach(this.addField, this);
     }
     toQueryParameterValue() {
-        const joinedFields = join$1.call(Object.keys(this.fields), SEPARATOR_BETWEEN_FIELDS);
+        const joinedFields = join.call(Object.keys(this.fields), SEPARATOR_BETWEEN_FIELDS);
         return this.isUnScoped()
             ? joinedFields
-            : join$1.call([this.scope, joinedFields], SEPARATOR_BETWEEN_SCOPE_AND_FIELDS);
+            : join.call([this.scope, joinedFields], SEPARATOR_BETWEEN_SCOPE_AND_FIELDS);
     }
     toQueryParams() {
         return this.isUnScoped() ? Object.keys(this.fields) : this.toQueryParameterValue();
@@ -49645,7 +49647,7 @@ class ScopedFieldsCollection {
             if (chunk !== undefined)
                 result.push(chunk);
         }
-        return join$1.call(result, SEPARATOR_BETWEEN_SCOPES);
+        return join.call(result, SEPARATOR_BETWEEN_SCOPES);
     }
     /**
      * split the ScopedFields into multiple ScopedFields
@@ -49818,12 +49820,12 @@ function buildAggregateUiUrl(params, resourceRequest) {
         optionalFields,
     };
     const queryString = [];
-    for (const [key, value] of entries$3(mergedParams)) {
+    for (const [key, value] of entries$2(mergedParams)) {
         if (value !== undefined) {
             queryString.push(`${key}=${isArray(value) ? value.join(',') : value}`);
         }
     }
-    return `${resourceRequest.baseUri}${resourceRequest.basePath}?${join$1.call(queryString, '&')}`;
+    return `${resourceRequest.baseUri}${resourceRequest.basePath}?${join.call(queryString, '&')}`;
 }
 function shouldUseAggregateUiForFields(fieldsArray, optionalFieldsArray, maxLengthPerChunk) {
     return fieldsArray.length + optionalFieldsArray.length >= maxLengthPerChunk;
@@ -49834,7 +49836,7 @@ function isSpanningRecord(fieldValue) {
 function mergeRecordFields(first, second) {
     const { fields: targetFields } = first;
     const { fields: sourceFields } = second;
-    const fieldNames = keys$3(sourceFields);
+    const fieldNames = keys$2(sourceFields);
     for (let i = 0, len = fieldNames.length; i < len; i += 1) {
         const fieldName = fieldNames[i];
         const sourceField = sourceFields[fieldName];
@@ -49932,7 +49934,7 @@ function buildCompositeRequestByFields(referenceId, resourceRequest, recordsComp
             const url = buildAggregateUiUrl({
                 fields: fieldChunk,
             }, resourceRequest);
-            push$1.call(compositeRequest, {
+            push.call(compositeRequest, {
                 url,
                 referenceId: `${referenceId}_fields_${i}`,
             });
@@ -49947,7 +49949,7 @@ function buildCompositeRequestByFields(referenceId, resourceRequest, recordsComp
             const url = buildAggregateUiUrl({
                 optionalFields: fieldChunk,
             }, resourceRequest);
-            push$1.call(compositeRequest, {
+            push.call(compositeRequest, {
                 url,
                 referenceId: `${referenceId}_optionalFields_${i}`,
             });
@@ -49987,8 +49989,8 @@ 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$2(request.urlParams).length : 0) +
-        stringify$2({ ...request.queryParams, fields: {}, optionalFields: {} }).length;
+        (request.urlParams ? stringify$1(request.urlParams).length : 0) +
+        stringify$1({ ...request.queryParams, fields: {}, optionalFields: {} }).length;
     // MAX_URL_LENGTH  - full lenght without fields, optionalFields
     return MAX_URL_LENGTH - roughUrlLengthWithoutFieldsAndOptionFields;
 }
@@ -49998,7 +50000,7 @@ function calculateEstimatedTotalUrlLength(request) {
     const { baseUri, basePath, queryParams } = request;
     let url = `${baseUri}${basePath}`;
     if (queryParams) {
-        const queryParamString = entries$3(queryParams)
+        const queryParamString = entries$2(queryParams)
             .map(([key, value]) => `${key}=${value}`)
             .join('&');
         if (queryParamString) {
@@ -50211,10 +50213,6 @@ function makeNetworkAdapterChunkRecordFields(networkAdapter, instrumentationSink
     }, networkAdapter);
 }
 
-const { keys: keys$2, create: create$2, assign: assign$2, entries: entries$2 } = Object;
-const { stringify: stringify$1, parse: parse$1 } = JSON;
-const { push, join, slice, shift } = Array.prototype;
-
 // so eslint doesn't complain about nimbus
 /* global __nimbus */
 /**
@@ -50230,10 +50228,10 @@ class NimbusDraftQueue {
         if (callProxyMethod === undefined) {
             return Promise.reject(new Error('callProxyMethod not defined on the nimbus plugin'));
         }
-        const serializedAction = stringify$1([handlerId, data]);
+        const serializedAction = stringify$4([handlerId, data]);
         return new Promise((resolve, reject) => {
             callProxyMethod('enqueue', serializedAction, (serializedActionResponse) => {
-                const response = parse$1(serializedActionResponse);
+                const response = parse$4(serializedActionResponse);
                 resolve(response);
             }, (errorMessage) => {
                 reject(new Error(errorMessage));
@@ -50254,8 +50252,8 @@ class NimbusDraftQueue {
             return Promise.reject(new Error('callProxyMethod not defined on the nimbus plugin'));
         }
         return new Promise((resolve, reject) => {
-            callProxyMethod('getQueueActions', stringify$1([]), (serializedQueue) => {
-                resolve(parse$1(serializedQueue));
+            callProxyMethod('getQueueActions', stringify$4([]), (serializedQueue) => {
+                resolve(parse$4(serializedQueue));
             }, (errorMessage) => {
                 reject(new Error(errorMessage));
             });
@@ -50266,17 +50264,17 @@ class NimbusDraftQueue {
         if (callProxyMethod === undefined) {
             return Promise.reject('callProxyMethod not defined on the nimbus plugin');
         }
-        const stringifiedArgs = stringify$1([action]);
+        const stringifiedArgs = stringify$4([action]);
         return new Promise((resolve, reject) => {
             callProxyMethod('getDataForAction', stringifiedArgs, (data) => {
                 if (data === undefined) {
                     resolve(undefined);
                 }
                 else {
-                    resolve(parse$1(data));
+                    resolve(parse$4(data));
                 }
             }, (serializedError) => {
-                reject(parse$1(serializedError));
+                reject(parse$4(serializedError));
             });
         });
     }
@@ -50346,7 +50344,7 @@ function normalizeError(err) {
     else if (typeof err === 'string') {
         return new Error(err);
     }
-    return new Error(stringify$1(err));
+    return new Error(stringify$4(err));
 }
 
 const O11Y_NAMESPACE_LDS_MOBILE = 'lds-mobile';
@@ -50563,7 +50561,7 @@ function instrumentDraftQueue(queue) {
             logError: false,
         });
     };
-    const overriddenQueue = create$2(queue, { mergeActions: { value: mergeActions } });
+    const overriddenQueue = create$5(queue, { mergeActions: { value: mergeActions } });
     overriddenQueue.registerOnChangedListener((draftQueueEvent) => {
         switch (draftQueueEvent.type) {
             case DraftQueueEventType.QueueStateChanged: {
@@ -50701,7 +50699,7 @@ function enableObjectInfoCaching(env, ensureObjectInfoCached) {
     function dataIsObjectInfo(key, data) {
         return incomingObjectInfos.has(key);
     }
-    return create$2(env, {
+    return create$5(env, {
         handleSuccessResponse: { value: handleSuccessResponse },
         storePublish: { value: storePublish },
     });
@@ -50802,8 +50800,8 @@ class ObjectInfoService {
             }
         };
         // Local in-memory cache for apiName to key prefixes
-        this.apiNameToKeyPrefixMemoryCache = create$2(null);
-        this.keyPrefixToApiNameMemoryCache = create$2(null);
+        this.apiNameToKeyPrefixMemoryCache = create$5(null);
+        this.keyPrefixToApiNameMemoryCache = create$5(null);
     }
     /**
      * Size of return map not necessarily correlated with number of inputs.  The
@@ -50954,8 +50952,8 @@ function registerReportObserver(reportObserver) {
         const index = reportObservers.indexOf(reportObserver);
         if (index > -1) {
             reportObservers = [
-                ...slice.call(reportObservers, 0, index),
-                ...slice.call(reportObservers, index + 1),
+                ...slice$1.call(reportObservers, 0, index),
+                ...slice$1.call(reportObservers, index + 1),
             ];
         }
     };
@@ -51595,7 +51593,7 @@ function makeEnvironmentGraphqlAware(environment) {
         }
         return environment.applyCachePolicy(luvio, adapterRequestContext, buildSnapshotContext, localBuildCachedSnapshot, buildNetworkSnapshot);
     };
-    return create$2(environment, {
+    return create$5(environment, {
         rebuildSnapshot: { value: rebuildSnapshot },
         applyCachePolicy: { value: applyCachePolicy },
         setDefaultCachePolicy: { value: environment.setDefaultCachePolicy.bind(environment) },
@@ -52873,7 +52871,7 @@ async function aggressiveTrim(data, deallocateFn, options = {}) {
     const batchSize = options.batchSize !== undefined ? options.batchSize : DEFAULT_MAX_BATCH_SIZE;
     let deallocatedCount = 0;
     const { pendingTrimKeys, retainedIds, storeRecords } = data;
-    const storeKeyLength = keys$2(storeRecords).length;
+    const storeKeyLength = keys$5(storeRecords).length;
     if (storeKeyLength <= maxStoreRecords) {
         return { deallocatedCount, trimKeysSkipped: pendingTrimKeys };
     }
@@ -52941,7 +52939,7 @@ function setupObserver() {
         registerReportObserver((report) => {
             __nimbus.plugins.LdsObserverPlugin.logAdapterExecution({
                 name: report.adapterName,
-                serializedConfig: stringify$1(report.config),
+                serializedConfig: stringify$4(report.config),
                 status: report.result,
                 duration: report.executionTime,
             });
@@ -53609,7 +53607,7 @@ const shouldFlush = (key, value) => {
     if (value && typeof value === 'object') {
         const fields = value.fields;
         if (fields && typeof fields === 'object') {
-            const keys = keys$2(fields);
+            const keys = keys$5(fields);
             for (const key of keys) {
                 const field = fields[key];
                 if (fields && field.__state && field.__state.pending === true) {
@@ -53778,4 +53776,4 @@ register({
 });
 
 export { O11Y_NAMESPACE_LDS_MOBILE, getRuntime, registerReportObserver, reportGraphqlQueryParseError };
-// version: 1.316.0-fd56ed976d
+// version: 1.317.0-374876d2a3