@salesforce/lds-runtime-mobile 1.315.0 → 1.317.0

package/dist/main.js

@@ -21,8 +21,9 @@ import { HttpStatusCode, setBypassDeepFreeze, StoreKeySet, serializeStructuredKe
 import { RECORD_ID_PREFIX as RECORD_ID_PREFIX$1, RECORD_FIELDS_KEY_JUNCTION as RECORD_FIELDS_KEY_JUNCTION$1, keyBuilderRecord, extractRecordIdFromStoreKey as extractRecordIdFromStoreKey$1, isStoreKeyRecordViewEntity as isStoreKeyRecordViewEntity$1, RECORD_REPRESENTATION_NAME as RECORD_REPRESENTATION_NAME$1, configuration, buildRecordRepKeyFromId as buildRecordRepKeyFromId$1, getRecordId18 as getRecordId18$1, getRecordsAdapterFactory as getRecordsAdapterFactory$1, RecordRepresentationRepresentationType, ObjectInfoRepresentationType, getObjectInfoAdapterFactory, getObjectInfosAdapterFactory, getObjectInfoDirectoryAdapterFactory, UiApiNamespace, RecordRepresentationType, RecordRepresentationTTL, RecordRepresentationVersion } from '@salesforce/lds-adapters-uiapi';
 import ldsIdempotencyWriteDisabled from '@salesforce/gate/lds.idempotencyWriteDisabled';
 import ldsBackdatingEnabled from '@salesforce/gate/lds.backdatingEnabled';
-import { Kind as Kind$1, buildSchema, isObjectType, defaultFieldResolver, visit, execute, parse as parse$8, extendSchema, isScalarType, print } from '@luvio/graphql-parser';
+import { Kind as Kind$1, buildSchema, isObjectType, defaultFieldResolver, visit as visit$1, execute, parse as parse$8, extendSchema, isScalarType, print } from '@luvio/graphql-parser';
 import FIRST_DAY_OF_WEEK from '@salesforce/i18n/firstDayOfWeek';
+import graphqQueryFieldLimit from '@salesforce/gate/lmr.graphqQueryFieldLimit';
 import caseSensitiveUserId from '@salesforce/user/Id';
 import { idleDetector, getInstrumentation } from 'o11y/client';
 import ldsUseShortUrlGate from '@salesforce/gate/lds.useShortUrl';
@@ -52,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';
@@ -277,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
         : [];
@@ -1843,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';
@@ -2123,6 +2124,11 @@ class DurableDraftQueue {
         this.userState = DraftQueueState.Stopped;
         this.uploadingActionId = undefined;
         this.timeoutHandler = undefined;
+        this.logger = typeof __nimbus !== 'undefined' &&
+            __nimbus.plugins !== undefined &&
+            __nimbus.plugins.JSLoggerPlugin !== undefined
+            ? __nimbus.plugins.JSLoggerPlugin
+            : undefined;
         this.handlers = {};
         this.draftStore = draftStore;
         this.workerPool = new AsyncWorkerPool(1);
@@ -2163,12 +2169,13 @@ class DurableDraftQueue {
         await this.notifyChangedListeners({
             type: DraftQueueEventType.QueueStateChanged,
             state: this.state,
+            draftCount: this.draftStore.getCount(),
         });
         const result = await this.processNextAction();
         switch (result) {
             case ProcessActionResult.BLOCKED_ON_ERROR:
                 this.state = DraftQueueState.Error;
-                return Promise.reject();
+                return Promise.reject('Unable to start queue - first action is in error state');
             default:
                 return Promise.resolve();
         }
@@ -2179,16 +2186,22 @@ class DurableDraftQueue {
             // Do nothing if the queue state is already stopped
             return Promise.resolve();
         }
-        this.stopQueueManually();
+        this.stopQueueManually(false);
         return this.notifyChangedListeners({
             type: DraftQueueEventType.QueueStateChanged,
             state: DraftQueueState.Stopped,
+            draftCount: this.draftStore.getCount(),
         });
     }
     /**
      * Used to stop the queue within DraftQueue without user interaction
      */
-    stopQueueManually() {
+    stopQueueManually(internalReason) {
+        if (this.logger) {
+            this.logger.logInfo(internalReason
+                ? 'Draft queue stopped for internal reason'
+                : 'Draft queue stopped by app');
+        }
         if (this.timeoutHandler) {
             clearTimeout(this.timeoutHandler);
             this.timeoutHandler = undefined;
@@ -2198,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;
@@ -2231,6 +2241,7 @@ class DurableDraftQueue {
                 await this.notifyChangedListeners({
                     type: DraftQueueEventType.ActionAdded,
                     action: pendingAction,
+                    draftCount: this.draftStore.getCount(),
                 });
                 await handler.handleActionEnqueued(pendingAction, queue);
                 if (this.state === DraftQueueState.Started) {
@@ -2263,6 +2274,7 @@ class DurableDraftQueue {
                 await this.notifyChangedListeners({
                     type: DraftQueueEventType.ActionCompleted,
                     action,
+                    draftCount: this.draftStore.getCount(),
                 });
                 if (this.state === DraftQueueState.Started) {
                     this.processNextAction();
@@ -2312,6 +2324,7 @@ class DurableDraftQueue {
             await this.notifyChangedListeners({
                 type: DraftQueueEventType.ActionFailed,
                 action: action,
+                draftCount: this.draftStore.getCount(),
             });
             return ProcessActionResult.BLOCKED_ON_ERROR;
         }
@@ -2328,6 +2341,7 @@ class DurableDraftQueue {
         await this.notifyChangedListeners({
             type: DraftQueueEventType.ActionUploading,
             action: { ...action, status: DraftActionStatus.Uploading },
+            draftCount: this.draftStore.getCount(),
         });
         return this.handle(action);
     }
@@ -2349,6 +2363,7 @@ class DurableDraftQueue {
         return this.notifyChangedListeners({
             type: DraftQueueEventType.ActionFailed,
             action: errorAction,
+            draftCount: this.draftStore.getCount(),
         });
     }
     async notifyChangedListeners(event) {
@@ -2395,6 +2410,7 @@ class DurableDraftQueue {
         await this.notifyChangedListeners({
             type: DraftQueueEventType.ActionDeleted,
             action,
+            draftCount: this.draftStore.getCount(),
         });
         if (this.userState === DraftQueueState.Started &&
             this.state !== DraftQueueState.Started &&
@@ -2404,7 +2420,7 @@ class DurableDraftQueue {
     }
     async updateDraftAction(action) {
         // stop queue manually
-        this.stopQueueManually();
+        this.stopQueueManually(true);
         const actionStatus = await this.statusOfAction(action.id);
         if (actionStatus === DraftActionStatus.Uploading) {
             return Promise.reject('cannot update an uploading action');
@@ -2434,7 +2450,7 @@ class DurableDraftQueue {
         return this.replaceOrMergeActions(targetActionId, sourceActionId, true);
     }
     async retryAction(actionId) {
-        this.stopQueueManually();
+        this.stopQueueManually(true);
         const actions = await this.getQueueActions();
         const target = actions[0];
         if (!target || target.id !== actionId) {
@@ -2452,6 +2468,7 @@ class DurableDraftQueue {
         await this.notifyChangedListeners({
             type: DraftQueueEventType.ActionUpdated,
             action: pendingAction,
+            draftCount: this.draftStore.getCount(),
         });
         await this.startQueueSafe();
         return pendingAction;
@@ -2477,6 +2494,7 @@ class DurableDraftQueue {
         await this.notifyChangedListeners({
             type: DraftQueueEventType.ActionUpdated,
             action: action,
+            draftCount: this.draftStore.getCount(),
         });
         return action;
     }
@@ -2484,6 +2502,7 @@ class DurableDraftQueue {
         await this.notifyChangedListeners({
             type: DraftQueueEventType.QueueStateChanged,
             state: DraftQueueState.Waiting,
+            draftCount: this.draftStore.getCount(),
         });
         this.timeoutHandler = setTimeout(() => {
             if (this.state !== DraftQueueState.Stopped) {
@@ -2542,7 +2561,7 @@ class DurableDraftQueue {
         if (this.replacingAction !== undefined) {
             throw Error('Cannot replace/merge actions while a replace/merge action operation is in progress.');
         }
-        this.stopQueueManually();
+        this.stopQueueManually(true);
         const promise = this.getActionsForReplaceOrMerge(targetActionId, sourceActionId).then(async ({ target, source }) => {
             // put in a try/finally block so we don't leave this.replacingAction
             // indefinitely set
@@ -2558,6 +2577,7 @@ class DurableDraftQueue {
                 await this.notifyChangedListeners({
                     type: DraftQueueEventType.ActionUpdated,
                     action: updatedTarget,
+                    draftCount: this.draftStore.getCount(),
                 });
                 // remove the source from queue
                 await this.removeDraftAction(sourceActionId);
@@ -2696,6 +2716,9 @@ class DurableDraftStore {
         };
         return this.enqueueAction(action);
     }
+    getCount() {
+        return keys$7(this.draftStore).length;
+    }
     /**
      * Runs a write operation against the draft store, if the initial
      * revive is still in progress, the action gets enqueued to run once the
@@ -2739,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();
             })
@@ -2791,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.
  */
@@ -3314,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':
@@ -3499,16 +3026,17 @@ class DraftManager {
             return Promise.reject('cannot edit incompatible action type or uploading actions');
         }
         action.data.body.fields = { ...action.data.body.fields, ...fields };
+        action.status = DraftActionStatus.Pending;
         await this.draftQueue.updateDraftAction(action);
         return this.buildDraftQueueItem(action);
     }
     isValidFieldMap(fields) {
         const keys$1 = keys$7(fields);
-        const validTypes = ['string', 'number', 'null', 'boolean'];
+        const validTypes = ['string', 'number', 'boolean'];
         for (let i = 0; i < keys$1.length; i++) {
             const key = keys$1[i];
             const value = fields[key];
-            if (!validTypes.includes(typeof value)) {
+            if (!validTypes.includes(typeof value) && value !== null) {
                 return false;
             }
         }
@@ -3536,6 +3064,7 @@ class DraftManager {
         }
         const data = action.data;
         data.body.fields = { ...data.body.fields, ...fields };
+        action.status = DraftActionStatus.Pending;
         await this.draftQueue.updateDraftAction(action);
         return this.buildDraftQueueItem(action);
     }
@@ -3553,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,
@@ -3652,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 = {};
@@ -3779,8 +3312,8 @@ 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 } = Array.prototype;
-const { isArray: isArray$3, from: from$2 } = Array;
+const { shift: shift$1 } = Array.prototype;
+const { isArray: isArray$4, from: from$3 } = Array;
 
 /**
  * Retrieves a denormalized record from the store
@@ -4008,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;
@@ -4179,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));
 }
@@ -4295,7 +4321,7 @@ function recursivelyApplyDraftsToRecord(record, draftMetadata, recordOperations)
         return record;
     }
     // remove the next item from the front of the queue
-    const draftOperation = shift.call(recordOperations);
+    const draftOperation = shift$1.call(recordOperations);
     if (draftOperation === undefined) {
         return record;
     }
@@ -4314,6 +4340,7 @@ function recursivelyApplyDraftsToRecord(record, draftMetadata, recordOperations)
             edited: false,
             deleted: false,
             serverValues: {},
+            serverRootValues: undefined,
             draftActionIds: [draftOperation.draftActionId],
             latestDraftActionId: draftOperation.draftActionId,
         };
@@ -4581,6 +4608,7 @@ function buildSyntheticRecordRepresentation(luvio, createOperation, userId, obje
             edited: false,
             deleted: false,
             serverValues: {},
+            serverRootValues: undefined,
             draftActionIds: [draftActionId],
             latestDraftActionId: draftActionId,
         },
@@ -5244,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';
@@ -5273,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
@@ -5417,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;
@@ -6872,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]];
@@ -7335,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];
@@ -7373,7 +7401,7 @@ function createPathSelection(propertyName, fieldDefinition) {
                 ],
             };
         }
-        push$2.call(fieldsSelection, fieldSelection);
+        push$1.call(fieldsSelection, fieldSelection);
     }
     return {
         kind: 'Object',
@@ -7386,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];
@@ -7421,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',
@@ -7431,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];
@@ -7440,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;
@@ -9390,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) {
@@ -9513,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]);
                 }
@@ -9671,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];
@@ -9802,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 [];
@@ -9845,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) {
@@ -10012,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;
@@ -10067,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++) {
@@ -10698,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;
@@ -10714,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),
             });
@@ -12145,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) {
@@ -15636,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;
@@ -16112,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,
@@ -16129,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: {
@@ -16251,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];
@@ -16270,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];
@@ -16313,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];
@@ -16340,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),
@@ -16401,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;
@@ -16531,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);
     }
@@ -16656,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;
@@ -16703,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;
@@ -16732,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);
@@ -16772,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
@@ -17011,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]: {},
                 });
             }
@@ -17747,7 +17775,7 @@ function typeCheckConfig$9(untrustedConfig) {
             }
         }
         if (records.length > 0) {
-            assign$5(config, { records });
+            assign$4(config, { records });
         }
     }
     return config;
@@ -42813,6 +42841,599 @@ var Kind = Object.freeze({
  * The enum type representing the possible kind values of AST nodes.
  */
 
+function invariant(condition, message) {
+  var booleanCondition = Boolean(condition); // istanbul ignore else (See transformation done in './resources/inlineInvariant.js')
+
+  if (!booleanCondition) {
+    throw new Error(message != null ? message : 'Unexpected invariant triggered.');
+  }
+}
+
+// istanbul ignore next (See: 'https://github.com/graphql/graphql-js/issues/2317')
+var nodejsCustomInspectSymbol = typeof Symbol === 'function' && typeof Symbol.for === 'function' ? Symbol.for('nodejs.util.inspect.custom') : undefined;
+var nodejsCustomInspectSymbol$1 = nodejsCustomInspectSymbol;
+
+/**
+ * The `defineInspect()` function defines `inspect()` prototype method as alias of `toJSON`
+ */
+
+function defineInspect(classObject) {
+  var fn = classObject.prototype.toJSON;
+  typeof fn === 'function' || invariant(0);
+  classObject.prototype.inspect = fn; // istanbul ignore else (See: 'https://github.com/graphql/graphql-js/issues/2317')
+
+  if (nodejsCustomInspectSymbol$1) {
+    classObject.prototype[nodejsCustomInspectSymbol$1] = fn;
+  }
+}
+
+/**
+ * Contains a range of UTF-8 character offsets and token references that
+ * identify the region of the source from which the AST derived.
+ */
+var Location = /*#__PURE__*/function () {
+  /**
+   * The character offset at which this Node begins.
+   */
+
+  /**
+   * The character offset at which this Node ends.
+   */
+
+  /**
+   * The Token at which this Node begins.
+   */
+
+  /**
+   * The Token at which this Node ends.
+   */
+
+  /**
+   * The Source document the AST represents.
+   */
+  function Location(startToken, endToken, source) {
+    this.start = startToken.start;
+    this.end = endToken.end;
+    this.startToken = startToken;
+    this.endToken = endToken;
+    this.source = source;
+  }
+
+  var _proto = Location.prototype;
+
+  _proto.toJSON = function toJSON() {
+    return {
+      start: this.start,
+      end: this.end
+    };
+  };
+
+  return Location;
+}(); // Print a simplified form when appearing in `inspect` and `util.inspect`.
+
+defineInspect(Location);
+/**
+ * Represents a range of characters represented by a lexical token
+ * within a Source.
+ */
+
+var Token = /*#__PURE__*/function () {
+  /**
+   * The kind of Token.
+   */
+
+  /**
+   * The character offset at which this Node begins.
+   */
+
+  /**
+   * The character offset at which this Node ends.
+   */
+
+  /**
+   * The 1-indexed line number on which this Token appears.
+   */
+
+  /**
+   * The 1-indexed column number at which this Token begins.
+   */
+
+  /**
+   * For non-punctuation tokens, represents the interpreted value of the token.
+   */
+
+  /**
+   * Tokens exist as nodes in a double-linked-list amongst all tokens
+   * including ignored tokens. <SOF> is always the first node and <EOF>
+   * the last.
+   */
+  function Token(kind, start, end, line, column, prev, value) {
+    this.kind = kind;
+    this.start = start;
+    this.end = end;
+    this.line = line;
+    this.column = column;
+    this.value = value;
+    this.prev = prev;
+    this.next = null;
+  }
+
+  var _proto2 = Token.prototype;
+
+  _proto2.toJSON = function toJSON() {
+    return {
+      kind: this.kind,
+      value: this.value,
+      line: this.line,
+      column: this.column
+    };
+  };
+
+  return Token;
+}(); // Print a simplified form when appearing in `inspect` and `util.inspect`.
+
+defineInspect(Token);
+/**
+ * @internal
+ */
+
+function isNode(maybeNode) {
+  return maybeNode != null && typeof maybeNode.kind === 'string';
+}
+/**
+ * The list of all possible AST node types.
+ */
+
+function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+var MAX_ARRAY_LENGTH = 10;
+var MAX_RECURSIVE_DEPTH = 2;
+/**
+ * Used to print values in error messages.
+ */
+
+function inspect(value) {
+  return formatValue(value, []);
+}
+
+function formatValue(value, seenValues) {
+  switch (_typeof(value)) {
+    case 'string':
+      return JSON.stringify(value);
+
+    case 'function':
+      return value.name ? "[function ".concat(value.name, "]") : '[function]';
+
+    case 'object':
+      if (value === null) {
+        return 'null';
+      }
+
+      return formatObjectValue(value, seenValues);
+
+    default:
+      return String(value);
+  }
+}
+
+function formatObjectValue(value, previouslySeenValues) {
+  if (previouslySeenValues.indexOf(value) !== -1) {
+    return '[Circular]';
+  }
+
+  var seenValues = [].concat(previouslySeenValues, [value]);
+  var customInspectFn = getCustomFn(value);
+
+  if (customInspectFn !== undefined) {
+    var customValue = customInspectFn.call(value); // check for infinite recursion
+
+    if (customValue !== value) {
+      return typeof customValue === 'string' ? customValue : formatValue(customValue, seenValues);
+    }
+  } else if (Array.isArray(value)) {
+    return formatArray(value, seenValues);
+  }
+
+  return formatObject(value, seenValues);
+}
+
+function formatObject(object, seenValues) {
+  var keys = Object.keys(object);
+
+  if (keys.length === 0) {
+    return '{}';
+  }
+
+  if (seenValues.length > MAX_RECURSIVE_DEPTH) {
+    return '[' + getObjectTag(object) + ']';
+  }
+
+  var properties = keys.map(function (key) {
+    var value = formatValue(object[key], seenValues);
+    return key + ': ' + value;
+  });
+  return '{ ' + properties.join(', ') + ' }';
+}
+
+function formatArray(array, seenValues) {
+  if (array.length === 0) {
+    return '[]';
+  }
+
+  if (seenValues.length > MAX_RECURSIVE_DEPTH) {
+    return '[Array]';
+  }
+
+  var len = Math.min(MAX_ARRAY_LENGTH, array.length);
+  var remaining = array.length - len;
+  var items = [];
+
+  for (var i = 0; i < len; ++i) {
+    items.push(formatValue(array[i], seenValues));
+  }
+
+  if (remaining === 1) {
+    items.push('... 1 more item');
+  } else if (remaining > 1) {
+    items.push("... ".concat(remaining, " more items"));
+  }
+
+  return '[' + items.join(', ') + ']';
+}
+
+function getCustomFn(object) {
+  var customInspectFn = object[String(nodejsCustomInspectSymbol$1)];
+
+  if (typeof customInspectFn === 'function') {
+    return customInspectFn;
+  }
+
+  if (typeof object.inspect === 'function') {
+    return object.inspect;
+  }
+}
+
+function getObjectTag(object) {
+  var tag = Object.prototype.toString.call(object).replace(/^\[object /, '').replace(/]$/, '');
+
+  if (tag === 'Object' && typeof object.constructor === 'function') {
+    var name = object.constructor.name;
+
+    if (typeof name === 'string' && name !== '') {
+      return name;
+    }
+  }
+
+  return tag;
+}
+
+/**
+ * A visitor is provided to visit, it contains the collection of
+ * relevant functions to be called during the visitor's traversal.
+ */
+
+var QueryDocumentKeys = {
+  Name: [],
+  Document: ['definitions'],
+  OperationDefinition: ['name', 'variableDefinitions', 'directives', 'selectionSet'],
+  VariableDefinition: ['variable', 'type', 'defaultValue', 'directives'],
+  Variable: ['name'],
+  SelectionSet: ['selections'],
+  Field: ['alias', 'name', 'arguments', 'directives', 'selectionSet'],
+  Argument: ['name', 'value'],
+  FragmentSpread: ['name', 'directives'],
+  InlineFragment: ['typeCondition', 'directives', 'selectionSet'],
+  FragmentDefinition: ['name', // Note: fragment variable definitions are experimental and may be changed
+  // or removed in the future.
+  'variableDefinitions', 'typeCondition', 'directives', 'selectionSet'],
+  IntValue: [],
+  FloatValue: [],
+  StringValue: [],
+  BooleanValue: [],
+  NullValue: [],
+  EnumValue: [],
+  ListValue: ['values'],
+  ObjectValue: ['fields'],
+  ObjectField: ['name', 'value'],
+  Directive: ['name', 'arguments'],
+  NamedType: ['name'],
+  ListType: ['type'],
+  NonNullType: ['type'],
+  SchemaDefinition: ['description', 'directives', 'operationTypes'],
+  OperationTypeDefinition: ['type'],
+  ScalarTypeDefinition: ['description', 'name', 'directives'],
+  ObjectTypeDefinition: ['description', 'name', 'interfaces', 'directives', 'fields'],
+  FieldDefinition: ['description', 'name', 'arguments', 'type', 'directives'],
+  InputValueDefinition: ['description', 'name', 'type', 'defaultValue', 'directives'],
+  InterfaceTypeDefinition: ['description', 'name', 'interfaces', 'directives', 'fields'],
+  UnionTypeDefinition: ['description', 'name', 'directives', 'types'],
+  EnumTypeDefinition: ['description', 'name', 'directives', 'values'],
+  EnumValueDefinition: ['description', 'name', 'directives'],
+  InputObjectTypeDefinition: ['description', 'name', 'directives', 'fields'],
+  DirectiveDefinition: ['description', 'name', 'arguments', 'locations'],
+  SchemaExtension: ['directives', 'operationTypes'],
+  ScalarTypeExtension: ['name', 'directives'],
+  ObjectTypeExtension: ['name', 'interfaces', 'directives', 'fields'],
+  InterfaceTypeExtension: ['name', 'interfaces', 'directives', 'fields'],
+  UnionTypeExtension: ['name', 'directives', 'types'],
+  EnumTypeExtension: ['name', 'directives', 'values'],
+  InputObjectTypeExtension: ['name', 'directives', 'fields']
+};
+var BREAK = Object.freeze({});
+/**
+ * visit() will walk through an AST using a depth-first traversal, calling
+ * the visitor's enter function at each node in the traversal, and calling the
+ * leave function after visiting that node and all of its child nodes.
+ *
+ * By returning different values from the enter and leave functions, the
+ * behavior of the visitor can be altered, including skipping over a sub-tree of
+ * the AST (by returning false), editing the AST by returning a value or null
+ * to remove the value, or to stop the whole traversal by returning BREAK.
+ *
+ * When using visit() to edit an AST, the original AST will not be modified, and
+ * a new version of the AST with the changes applied will be returned from the
+ * visit function.
+ *
+ *     const editedAST = visit(ast, {
+ *       enter(node, key, parent, path, ancestors) {
+ *         // @return
+ *         //   undefined: no action
+ *         //   false: skip visiting this node
+ *         //   visitor.BREAK: stop visiting altogether
+ *         //   null: delete this node
+ *         //   any value: replace this node with the returned value
+ *       },
+ *       leave(node, key, parent, path, ancestors) {
+ *         // @return
+ *         //   undefined: no action
+ *         //   false: no action
+ *         //   visitor.BREAK: stop visiting altogether
+ *         //   null: delete this node
+ *         //   any value: replace this node with the returned value
+ *       }
+ *     });
+ *
+ * Alternatively to providing enter() and leave() functions, a visitor can
+ * instead provide functions named the same as the kinds of AST nodes, or
+ * enter/leave visitors at a named key, leading to four permutations of the
+ * visitor API:
+ *
+ * 1) Named visitors triggered when entering a node of a specific kind.
+ *
+ *     visit(ast, {
+ *       Kind(node) {
+ *         // enter the "Kind" node
+ *       }
+ *     })
+ *
+ * 2) Named visitors that trigger upon entering and leaving a node of
+ *    a specific kind.
+ *
+ *     visit(ast, {
+ *       Kind: {
+ *         enter(node) {
+ *           // enter the "Kind" node
+ *         }
+ *         leave(node) {
+ *           // leave the "Kind" node
+ *         }
+ *       }
+ *     })
+ *
+ * 3) Generic visitors that trigger upon entering and leaving any node.
+ *
+ *     visit(ast, {
+ *       enter(node) {
+ *         // enter any node
+ *       },
+ *       leave(node) {
+ *         // leave any node
+ *       }
+ *     })
+ *
+ * 4) Parallel visitors for entering and leaving nodes of a specific kind.
+ *
+ *     visit(ast, {
+ *       enter: {
+ *         Kind(node) {
+ *           // enter the "Kind" node
+ *         }
+ *       },
+ *       leave: {
+ *         Kind(node) {
+ *           // leave the "Kind" node
+ *         }
+ *       }
+ *     })
+ */
+
+function visit(root, visitor) {
+  var visitorKeys = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : QueryDocumentKeys;
+
+  /* eslint-disable no-undef-init */
+  var stack = undefined;
+  var inArray = Array.isArray(root);
+  var keys = [root];
+  var index = -1;
+  var edits = [];
+  var node = undefined;
+  var key = undefined;
+  var parent = undefined;
+  var path = [];
+  var ancestors = [];
+  var newRoot = root;
+  /* eslint-enable no-undef-init */
+
+  do {
+    index++;
+    var isLeaving = index === keys.length;
+    var isEdited = isLeaving && edits.length !== 0;
+
+    if (isLeaving) {
+      key = ancestors.length === 0 ? undefined : path[path.length - 1];
+      node = parent;
+      parent = ancestors.pop();
+
+      if (isEdited) {
+        if (inArray) {
+          node = node.slice();
+        } else {
+          var clone = {};
+
+          for (var _i2 = 0, _Object$keys2 = Object.keys(node); _i2 < _Object$keys2.length; _i2++) {
+            var k = _Object$keys2[_i2];
+            clone[k] = node[k];
+          }
+
+          node = clone;
+        }
+
+        var editOffset = 0;
+
+        for (var ii = 0; ii < edits.length; ii++) {
+          var editKey = edits[ii][0];
+          var editValue = edits[ii][1];
+
+          if (inArray) {
+            editKey -= editOffset;
+          }
+
+          if (inArray && editValue === null) {
+            node.splice(editKey, 1);
+            editOffset++;
+          } else {
+            node[editKey] = editValue;
+          }
+        }
+      }
+
+      index = stack.index;
+      keys = stack.keys;
+      edits = stack.edits;
+      inArray = stack.inArray;
+      stack = stack.prev;
+    } else {
+      key = parent ? inArray ? index : keys[index] : undefined;
+      node = parent ? parent[key] : newRoot;
+
+      if (node === null || node === undefined) {
+        continue;
+      }
+
+      if (parent) {
+        path.push(key);
+      }
+    }
+
+    var result = void 0;
+
+    if (!Array.isArray(node)) {
+      if (!isNode(node)) {
+        throw new Error("Invalid AST Node: ".concat(inspect(node), "."));
+      }
+
+      var visitFn = getVisitFn(visitor, node.kind, isLeaving);
+
+      if (visitFn) {
+        result = visitFn.call(visitor, node, key, parent, path, ancestors);
+
+        if (result === BREAK) {
+          break;
+        }
+
+        if (result === false) {
+          if (!isLeaving) {
+            path.pop();
+            continue;
+          }
+        } else if (result !== undefined) {
+          edits.push([key, result]);
+
+          if (!isLeaving) {
+            if (isNode(result)) {
+              node = result;
+            } else {
+              path.pop();
+              continue;
+            }
+          }
+        }
+      }
+    }
+
+    if (result === undefined && isEdited) {
+      edits.push([key, node]);
+    }
+
+    if (isLeaving) {
+      path.pop();
+    } else {
+      var _visitorKeys$node$kin;
+
+      stack = {
+        inArray: inArray,
+        index: index,
+        keys: keys,
+        edits: edits,
+        prev: stack
+      };
+      inArray = Array.isArray(node);
+      keys = inArray ? node : (_visitorKeys$node$kin = visitorKeys[node.kind]) !== null && _visitorKeys$node$kin !== void 0 ? _visitorKeys$node$kin : [];
+      index = -1;
+      edits = [];
+
+      if (parent) {
+        ancestors.push(parent);
+      }
+
+      parent = node;
+    }
+  } while (stack !== undefined);
+
+  if (edits.length !== 0) {
+    newRoot = edits[edits.length - 1][1];
+  }
+
+  return newRoot;
+}
+/**
+ * Given a visitor instance, if it is leaving or not, and a node kind, return
+ * the function the visitor runtime should call.
+ */
+
+function getVisitFn(visitor, kind, isLeaving) {
+  var kindVisitor = visitor[kind];
+
+  if (kindVisitor) {
+    if (!isLeaving && typeof kindVisitor === 'function') {
+      // { Kind() {} }
+      return kindVisitor;
+    }
+
+    var kindSpecificVisitor = isLeaving ? kindVisitor.leave : kindVisitor.enter;
+
+    if (typeof kindSpecificVisitor === 'function') {
+      // { Kind: { enter() {}, leave() {} } }
+      return kindSpecificVisitor;
+    }
+  } else {
+    var specificVisitor = isLeaving ? visitor.leave : visitor.enter;
+
+    if (specificVisitor) {
+      if (typeof specificVisitor === 'function') {
+        // { enter() {}, leave() {} }
+        return specificVisitor;
+      }
+
+      var specificKindVisitor = specificVisitor[kind];
+
+      if (typeof specificKindVisitor === 'function') {
+        // { enter: { Kind() {} }, leave: { Kind() {} } }
+        return specificKindVisitor;
+      }
+    }
+  }
+}
+
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
  * All rights reserved.
@@ -42955,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) {
@@ -42968,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;
                 }
@@ -43327,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';
@@ -43631,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));
@@ -43656,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}`;
@@ -43680,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) => {
@@ -43710,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.
@@ -44284,6 +44909,12 @@ function isObjectValueNode(node) {
 function isStringValueNode(node) {
     return node.kind === Kind$1.STRING;
 }
+function isIntValueNode(node) {
+    return node.kind === Kind$1.INT;
+}
+function isVariableNode(node) {
+    return node.kind === Kind$1.VARIABLE;
+}
 function isFieldNode(node) {
     return node !== undefined && node.kind !== undefined ? node.kind === 'Field' : false;
 }
@@ -44875,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) => {
@@ -44928,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;
@@ -44958,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])
@@ -45173,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;
@@ -45278,7 +45909,7 @@ function mapCursorValue(originalValue, paginationMetadata) {
 async function mapPaginationCursors(originalAST, variables, store) {
     // first pass, identify record query cache keys for reading pagination metadata
     let requiredPaginationMetadataKeys = [];
-    visit(originalAST, {
+    visit$1(originalAST, {
         Field(node, _key, _parent, _path, ancestors) {
             // is it a record query?
             if (!isRecordQuery(node)) {
@@ -45306,7 +45937,7 @@ async function mapPaginationCursors(originalAST, variables, store) {
     // holds the original cursor values that were mapped back to server cursors
     let mappedCursors = new Map();
     // rewrite nodes/variables with mapped cursors now that we read the pagination metadata
-    let ast = visit(originalAST, {
+    let ast = visit$1(originalAST, {
         Field(node, _key, _parent, _path, ancestors) {
             // is it a record query?
             if (!isRecordQuery(node)) {
@@ -45384,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;
@@ -45488,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);
@@ -45562,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)
         : '';
@@ -45977,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);
@@ -46104,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));
@@ -46321,7 +46952,7 @@ async function evaluate(config, observers, settings, objectInfos, store, snapsho
         const operationNode = getOperationFromDocument(config.query);
         let topLevelQueries = [];
         // assume that 'config.query' has required injected fields.
-        const modifiedAST = visit(config.query, {
+        const modifiedAST = visit$1(config.query, {
             Field: {
                 leave(node) {
                     if (node.name.value !== `node`)
@@ -46461,7 +47092,7 @@ async function injectSyntheticFields(originalAST, objectInfoService, draftFuncti
         unmappedDraftIDs: new Set(),
     };
     let assignedtomeQueryFieldNode = undefined;
-    visit(originalAST, {
+    visit$1(originalAST, {
         Argument: {
             enter(node, key, parent, path, ancestors) {
                 const { connection: recordConnectionNode, path: ancesterPath } = findNearestConnectionWithPath(ancestors);
@@ -46533,7 +47164,7 @@ async function injectSyntheticFields(originalAST, objectInfoService, draftFuncti
         objectInfos = await resolveObjectInfos(objectNodeInfoTree, pathToObjectApiNamesMap, startNodes, objectInfoService);
     }
     // read pass; gather whats needed
-    visit(originalAST, {
+    visit$1(originalAST, {
         Argument: {
             leave(node, key, parent, path, ancestors) {
                 const recordQueryField = findNearestConnection(ancestors);
@@ -46618,7 +47249,7 @@ async function injectSyntheticFields(originalAST, objectInfoService, draftFuncti
         },
     });
     // write pass; inject whats needed
-    const modifiedAST = visit(originalAST, {
+    const modifiedAST = visit$1(originalAST, {
         Field: {
             leave(node, key, parent, path, ancestors) {
                 // removes 'ServicesResources' query field node if 'assignedtome' scope shows up
@@ -46963,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)}`);
     }
@@ -47904,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
@@ -47924,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);
     }
@@ -47933,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)) {
@@ -48035,8 +48666,9 @@ function createErrorSnapshot(result, snapshot) {
         },
     };
 }
-function createLocalEvalSnapshot(data, seenRecords, recordId, rebuildWithLocalEval) {
+function createLocalEvalSnapshot(data, seenRecords, recordId, rebuildWithLocalEval, refresh) {
     return {
+        refresh,
         recordId,
         variables: {},
         seenRecords,
@@ -48147,7 +48779,7 @@ function instrumentLimits(ast, variables) {
     let currentChildRelationships = 0;
     let currentRootRecordCount = 0;
     let currentTotalRecordCount = 0;
-    visit(ast, {
+    visit$1(ast, {
         Field: {
             enter(node) {
                 if (isRecordQuery(node)) {
@@ -48198,6 +48830,95 @@ function limitForQuery(field, variables) {
     return first;
 }
 
+const MAX_RECORD_QUERY_FIELD_COUNT = 100;
+const MAX_RECORD_QUERY_LIMIT = 200;
+function enforceFieldLimitOnAST(ast, variables, enforcedLimits = {
+    maxFieldCount: MAX_RECORD_QUERY_FIELD_COUNT,
+    maxRecordLimit: MAX_RECORD_QUERY_LIMIT,
+}) {
+    const { maxFieldCount, maxRecordLimit } = enforcedLimits;
+    const documentNode = visit(ast, {
+        Field(node) {
+            // is it a record query?
+            if (!isRecordQuery(node)) {
+                return;
+            }
+            // check to see that we have the `first` argument defined
+            if (node.arguments === undefined)
+                return false;
+            let first = node.arguments.find((node) => {
+                return node.name.value === 'first';
+            });
+            if (first === undefined)
+                return false;
+            if (isIntValueNode(first.value) || isVariableNode(first.value)) {
+                // total number of requested fields in a record query
+                const fieldCount = findRecordQueryNodeFieldCount(node);
+                if (isIntValueNode(first.value)) {
+                    const originalValue = Number(first.value.value);
+                    if (isNaN(originalValue))
+                        return false;
+                    // if the `first` value is already less than the `maxRecordLimit`
+                    // or the field count is less than `maxFieldCount` then
+                    // there is no need to update the argument node value
+                    if (originalValue <= maxRecordLimit || fieldCount <= maxFieldCount)
+                        return false;
+                    // else we cap the truncated limit
+                    return {
+                        ...node,
+                        arguments: node.arguments.map((argument) => {
+                            if (argument !== first)
+                                return argument;
+                            return {
+                                ...argument,
+                                value: {
+                                    kind: Kind.INT,
+                                    value: maxRecordLimit,
+                                },
+                            };
+                        }),
+                    };
+                }
+                else if (isVariableNode(first.value) && variables !== undefined) {
+                    const variableName = first.value.name.value;
+                    // ensure the variable is a number
+                    const variableValue = Number(variables[variableName]);
+                    if (isNaN(variableValue))
+                        return;
+                    // if the variable is less than the `maxRecordLimit` or
+                    // field count is less then `maxFieldCount`
+                    // then there is no need to alter the variable
+                    if (variableValue <= maxRecordLimit || fieldCount <= maxFieldCount)
+                        return;
+                    // else we update the variable to the truncated limited
+                    variables[variableName] = maxRecordLimit;
+                }
+            }
+        },
+    });
+    return documentNode;
+}
+/**
+ * Count all the requested fields to be returned in the users request
+ * @param recordQueryNode
+ * @returns
+ */
+function findRecordQueryNodeFieldCount(recordQueryNode) {
+    if (recordQueryNode.selectionSet === undefined)
+        return 0;
+    const edges = recordQueryNode.selectionSet.selections.filter(isFieldNode).find((node) => {
+        return node.name.value === 'edges';
+    });
+    if (edges === undefined || edges.selectionSet === undefined)
+        return 0;
+    const node = edges.selectionSet.selections.filter(isFieldNode).find((node) => {
+        return node.name.value === 'node';
+    });
+    if (node === undefined || node.selectionSet === undefined)
+        return 0;
+    return node.selectionSet.selections.length || 0;
+}
+
 function generateUniqueRecordId() {
     return `UiApi::GraphQLRepresentation:${Date.now() + Math.random().toFixed(5).split('.')[1]}`;
 }
@@ -48219,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;
             }, {});
@@ -48228,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;
     }, {});
@@ -48240,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
@@ -48255,11 +48976,11 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
             isDraftId,
             getCanonicalId,
         };
+        const eventEmitter = createCustomAdapterEventEmitter(GRAPHQL_EVAL_NAMESPACE, requestContext.eventObservers || []);
         try {
             // NB: This occurs BEFORE synthetic field injection on purpose to
             // ensure we don't charge the caller for spanning records we inject
             // on their behalf.
-            const eventEmitter = createCustomAdapterEventEmitter(GRAPHQL_EVAL_NAMESPACE, requestContext.eventObservers || []);
             const queryInstrumentation = instrumentLimits(copy, config.variables || {});
             eventEmitter({
                 type: 'graphql-query-instrumentation',
@@ -48269,12 +48990,17 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
         catch (_a) {
             // ignore errors instrumenting limits
         }
+        let fieldLimitedAST = copy;
+        if (graphqQueryFieldLimit.isOpen({ fallback: true })) {
+            // enfore server field count limits on the AST
+            fieldLimitedAST = enforceFieldLimitOnAST(copy, config.variables || {});
+        }
         try {
             ({
                 modifiedAST: injectedAST,
                 objectInfos: objectInfoNeeded,
                 unmappedDraftIDs,
-            } = await injectSyntheticFields(copy, objectInfoService, draftFunctions, config.variables));
+            } = await injectSyntheticFields(fieldLimitedAST, objectInfoService, draftFunctions, config.variables));
             ({ ast: cursorMappedAST, mappedCursors } = await mapPaginationCursors(injectedAST, config.variables || {}, store));
             if (config.variables) {
                 config.variables = replaceDraftIdsInVariables(config.variables, draftFunctions, unmappedDraftIDs);
@@ -48329,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) {
@@ -48391,7 +49117,7 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
         // the error is network error or 504), otherwise we spread over
         // the non-eval'ed snapshot (which will be either Fulfilled or Stale)
         const resultSnapshot = nonEvaluatedSnapshot.state === 'Error'
-            ? createLocalEvalSnapshot(gqlResult, seenRecords, recordId, rebuildWithLocalEval)
+            ? createLocalEvalSnapshot(gqlResult, seenRecords, recordId, rebuildWithLocalEval, nonEvaluatedSnapshot.refresh)
             : {
                 ...nonEvaluatedSnapshot,
                 data: gqlResult,
@@ -48414,6 +49140,9 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
                 },
             };
         }
+        if (refresh === undefined) {
+            eventEmitter({ type: 'graphql-luvio-refresh-undefined' });
+        }
         if (possibleStaleRecordMap.size > 0) {
             initiateStaleRecordRefresh(luvio, possibleStaleRecordMap);
             resultSnapshot.state = 'Stale';
@@ -48442,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 = {
@@ -48666,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];
@@ -48690,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;
@@ -48750,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;
@@ -48847,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();
@@ -48918,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
@@ -49091,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;
@@ -49107,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];
@@ -49205,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}`,
             });
@@ -49220,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}`,
             });
@@ -49260,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;
 }
@@ -49271,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) {
@@ -49484,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 } = Array.prototype;
-
 // so eslint doesn't complain about nimbus
 /* global __nimbus */
 /**
@@ -49503,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));
@@ -49527,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));
             });
@@ -49539,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));
             });
         });
     }
@@ -49619,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';
@@ -49631,6 +50356,7 @@ const GRAPHQL_EVAL_ROOT_QUERY_COUNT = 'gql-eval-root-query-count';
 const GRAPHQL_EVAL_TOTAL_QUERY_COUNT = 'gql-eval-total-query-count';
 const GRAPHQL_EVAL_MAX_CHILD_RELATIONSHIPS_COUNT = 'gql-eval-max-child-count';
 const GRAPHQL_EVAL_QUERY_RECORD_COUNT = 'gql-eval-query-record-count';
+const GRAPHQL_SNAPSHOT_REFRESH_UNDEFINED = 'gql-snapshot-refresh-undefined';
 /** Draft Queue */
 const DRAFT_QUEUE_STATE_STARTED = 'draft-queue-state-started';
 const DRAFT_QUEUE_STATE_ERROR = 'draft-queue-state-error';
@@ -49657,6 +50383,11 @@ const GRAPHQL_SQL_EVAL_PRECONDITION_ERROR = 'gql-sql-pre-eval-error';
 const GRAPHQL_CREATE_SNAPSHOT_ERROR = 'gql-create-snapshot-error';
 const DRAFT_AWARE_CREATE_CONTENT_DOCUMENT_AND_VERSION_ERROR = 'draft-aware-create-content-document-and-version-error';
 const ldsMobileInstrumentation = getInstrumentation(O11Y_NAMESPACE_LDS_MOBILE);
+const nimbusLogger = typeof __nimbus !== 'undefined' &&
+    __nimbus.plugins !== undefined &&
+    __nimbus.plugins.JSLoggerPlugin !== undefined
+    ? __nimbus.plugins.JSLoggerPlugin
+    : undefined;
 function reportGraphqlQueryParseError(err) {
     const error = normalizeError(err);
     const errorCode = GRAPHQL_QUERY_PARSE_ERROR;
@@ -49698,7 +50429,13 @@ function reportGraphqlQueryInstrumentation(data) {
     ldsMobileInstrumentation.bucketValue(GRAPHQL_EVAL_MAX_CHILD_RELATIONSHIPS_COUNT, data.maxChildRelationships, queryBuckets);
     ldsMobileInstrumentation.bucketValue(GRAPHQL_EVAL_QUERY_RECORD_COUNT, data.requestedRecordCount, recordBuckets);
 }
-function reportDraftActionEvent(state) {
+function incrementGraphQLRefreshUndfined() {
+    ldsMobileInstrumentation.incrementCounter(GRAPHQL_SNAPSHOT_REFRESH_UNDEFINED);
+}
+function reportDraftActionEvent(state, draftCount, message) {
+    if (nimbusLogger) {
+        nimbusLogger.logInfo(`Draft action event: ${state}, depth: ${draftCount}${message ? `, message: ${message}` : ''}`);
+    }
     switch (state) {
         case 'added':
             ldsMobileInstrumentation.incrementCounter(DRAFT_QUEUE_ACTION_ADDED);
@@ -49720,7 +50457,10 @@ function reportDraftActionEvent(state) {
             break;
     }
 }
-function reportDraftQueueState(state) {
+function reportDraftQueueState(state, draftCount) {
+    if (nimbusLogger) {
+        nimbusLogger.logInfo(`Draft state changed: ${state}, depth: ${draftCount}`);
+    }
     switch (state) {
         case 'started':
             ldsMobileInstrumentation.incrementCounter(DRAFT_QUEUE_STATE_STARTED);
@@ -49814,53 +50554,73 @@ const withInstrumentation = (operation, config) => {
  * A HOF that returns an instrumented DraftQueue
  */
 function instrumentDraftQueue(queue) {
-    queue.registerOnChangedListener((draftQueueEvent) => {
+    const mergeActions = function (targetActionId, sourceActionId) {
+        return withInstrumentation(() => queue.mergeActions(targetActionId, sourceActionId), {
+            metricName: DRAFT_QUEUE_TOTAL_MERGE_ACTIONS_CALLS,
+            tags: {},
+            logError: false,
+        });
+    };
+    const overriddenQueue = create$5(queue, { mergeActions: { value: mergeActions } });
+    overriddenQueue.registerOnChangedListener((draftQueueEvent) => {
         switch (draftQueueEvent.type) {
-            case DraftQueueEventType.QueueStateChanged:
+            case DraftQueueEventType.QueueStateChanged: {
                 switch (draftQueueEvent.state) {
                     case DraftQueueState.Error:
-                        reportDraftQueueState('error');
+                        reportDraftQueueState('error', draftQueueEvent.draftCount);
                         break;
                     case DraftQueueState.Started:
-                        reportDraftQueueState('started');
+                        reportDraftQueueState('started', draftQueueEvent.draftCount);
                         break;
                     case DraftQueueState.Stopped:
-                        reportDraftQueueState('stopped');
+                        reportDraftQueueState('stopped', draftQueueEvent.draftCount);
                         break;
                     case DraftQueueState.Waiting:
-                        reportDraftQueueState('waiting');
+                        reportDraftQueueState('waiting', draftQueueEvent.draftCount);
                         break;
                 }
                 break;
+            }
             case DraftQueueEventType.ActionAdded:
-                reportDraftActionEvent('added');
+                reportDraftActionEvent('added', draftQueueEvent.draftCount);
                 break;
             case DraftQueueEventType.ActionUploading:
-                reportDraftActionEvent('uploading');
+                reportDraftActionEvent('uploading', draftQueueEvent.draftCount);
                 break;
             case DraftQueueEventType.ActionCompleted:
-                reportDraftActionEvent('completed');
+                reportDraftActionEvent('completed', draftQueueEvent.draftCount);
                 break;
             case DraftQueueEventType.ActionDeleted:
-                reportDraftActionEvent('deleted');
+                reportDraftActionEvent('deleted', draftQueueEvent.draftCount);
                 break;
             case DraftQueueEventType.ActionFailed:
-                reportDraftActionEvent('failed');
+                {
+                    const failedEvent = draftQueueEvent;
+                    const failureMessage = obtainFailureMessage(failedEvent.action.error);
+                    reportDraftActionEvent('failed', draftQueueEvent.draftCount, failureMessage);
+                }
                 break;
             case DraftQueueEventType.ActionUpdated:
-                reportDraftActionEvent('updated');
+                reportDraftActionEvent('updated', draftQueueEvent.draftCount);
                 break;
         }
         return Promise.resolve();
     });
-    const mergeActions = function (targetActionId, sourceActionId) {
-        return withInstrumentation(() => queue.mergeActions(targetActionId, sourceActionId), {
-            metricName: DRAFT_QUEUE_TOTAL_MERGE_ACTIONS_CALLS,
-            tags: {},
-            logError: false,
-        });
-    };
-    return create$2(queue, { mergeActions: { value: mergeActions } });
+    return overriddenQueue;
+}
+function obtainFailureMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    else if (typeof error === 'string') {
+        return error;
+    }
+    else if (error.status && error.statusText) {
+        return `status=${error.status}-${error.statusText}`;
+    }
+    else {
+        return JSON.stringify(error);
+    }
 }
 
 // so eslint doesn't complain about nimbus
@@ -49939,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 },
     });
@@ -50040,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
@@ -50066,6 +50826,10 @@ class ObjectInfoService {
         }
         return objectInfos;
     }
+    async getObjectInfo(apiName) {
+        const map = await this.getObjectInfos([apiName]);
+        return map[apiName];
+    }
     async getObjectInfoDirectory() {
         const snapshot = await this.getObjectInfoDirectoryAdapter({});
         if (!snapshot ||
@@ -50114,6 +50878,9 @@ function instrumentGraphQLEval(adapter) {
                     case 'graphql-query-instrumentation':
                         reportGraphqlQueryInstrumentation(data.data);
                         break;
+                    case 'graphql-luvio-refresh-undefined':
+                        incrementGraphQLRefreshUndfined();
+                        break;
                 }
             }
         },
@@ -50185,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),
             ];
         }
     };
@@ -50826,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) },
@@ -52104,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 };
     }
@@ -52172,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,
             });
@@ -52335,7 +53102,7 @@ function stripMetaschemaFromFieldNode(fieldNode) {
     return fieldNode;
 }
 function stripDocumentOfMetaschema(documentNode) {
-    return visit(documentNode, {
+    return visit$1(documentNode, {
         Field(node) {
             return stripMetaschemaFromFieldNode(node);
         },
@@ -52840,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) {
@@ -53009,4 +53776,4 @@ register({
 });
 
 export { O11Y_NAMESPACE_LDS_MOBILE, getRuntime, registerReportObserver, reportGraphqlQueryParseError };
-// version: 1.315.0-8ef4c90baf
+// version: 1.317.0-374876d2a3