@salesforce/lds-runtime-mobile 1.299.0 → 1.301.0

package/dist/main.js

@@ -19,11 +19,10 @@ import { withRegistration, register } from '@salesforce/lds-default-luvio';
 import { setupInstrumentation, instrumentAdapter as instrumentAdapter$1, instrumentLuvio, setLdsAdaptersUiapiInstrumentation, setLdsNetworkAdapterInstrumentation } from '@salesforce/lds-instrumentation';
 import { HttpStatusCode, setBypassDeepFreeze, StoreKeySet, serializeStructuredKey, StringKeyInMemoryStore, Reader, deepFreeze, emitAdapterEvent, createCustomAdapterEventEmitter, StoreKeyMap, isFileReference, Environment, Luvio, InMemoryStore } from '@luvio/engine';
 import excludeStaleRecordsGate from '@salesforce/gate/lds.graphqlEvalExcludeStaleRecords';
-import { parseAndVisit, Kind, buildSchema, isObjectType, defaultFieldResolver, visit, execute, parse as parse$7, extendSchema, isScalarType } from '@luvio/graphql-parser';
-import { RECORD_ID_PREFIX, RECORD_FIELDS_KEY_JUNCTION, RECORD_REPRESENTATION_NAME, extractRecordIdFromStoreKey, keyBuilderQuickActionExecutionRepresentation, ingestQuickActionExecutionRepresentation, keyBuilderContentDocumentCompositeRepresentation, getResponseCacheKeysContentDocumentCompositeRepresentation, keyBuilderFromTypeContentDocumentCompositeRepresentation, ingestContentDocumentCompositeRepresentation, keyBuilderRecord, getTypeCacheKeysRecord, keyBuilderFromTypeRecordRepresentation, ingestRecord, getRecordId18, RecordRepresentationRepresentationType, ObjectInfoRepresentationType, getRecordAdapterFactory, getObjectInfoAdapterFactory, getObjectInfosAdapterFactory, getObjectInfoDirectoryAdapterFactory, UiApiNamespace, RecordRepresentationType, RecordRepresentationTTL, RecordRepresentationVersion, getRecordsAdapterFactory } from '@salesforce/lds-adapters-uiapi-mobile';
+import { parseAndVisit, Kind as Kind$1, buildSchema, isObjectType, defaultFieldResolver, visit, execute, parse as parse$7, extendSchema, isScalarType } from '@luvio/graphql-parser';
+import { RECORD_ID_PREFIX, RECORD_FIELDS_KEY_JUNCTION, RECORD_REPRESENTATION_NAME, extractRecordIdFromStoreKey, keyBuilderQuickActionExecutionRepresentation, ingestQuickActionExecutionRepresentation, keyBuilderContentDocumentCompositeRepresentation, getResponseCacheKeysContentDocumentCompositeRepresentation, keyBuilderFromTypeContentDocumentCompositeRepresentation, ingestContentDocumentCompositeRepresentation, keyBuilderRecord, isStoreKeyRecordViewEntity, getTypeCacheKeysRecord, keyBuilderFromTypeRecordRepresentation, ingestRecord, getRecordId18, RecordRepresentationRepresentationType, ObjectInfoRepresentationType, getRecordAdapterFactory, getObjectInfoAdapterFactory, getObjectInfosAdapterFactory, getObjectInfoDirectoryAdapterFactory, UiApiNamespace, RecordRepresentationType, RecordRepresentationTTL, RecordRepresentationVersion, getRecordsAdapterFactory } from '@salesforce/lds-adapters-uiapi-mobile';
 import ldsIdempotencyWriteDisabled from '@salesforce/gate/lds.idempotencyWriteDisabled';
 import ldsBackdatingEnabled from '@salesforce/gate/lds.backdatingEnabled';
-import { extractRecordIdFromStoreKey as extractRecordIdFromStoreKey$1, RECORD_VIEW_ENTITY_ID_PREFIX, isStoreKeyRecordViewEntity, keyBuilderRecord as keyBuilderRecord$1, RECORD_ID_PREFIX as RECORD_ID_PREFIX$1, RECORD_FIELDS_KEY_JUNCTION as RECORD_FIELDS_KEY_JUNCTION$1 } from '@salesforce/lds-adapters-uiapi';
 import FIRST_DAY_OF_WEEK from '@salesforce/i18n/firstDayOfWeek';
 import caseSensitiveUserId from '@salesforce/user/Id';
 import { idleDetector, getInstrumentation } from 'o11y/client';
@@ -43,6 +42,7 @@ import eagerEvalDefaultCachePolicy from '@salesforce/gate/lds.eagerEvalDefaultCa
 import ldsPrimingGraphqlBatch from '@salesforce/gate/lds.primingGraphqlBatch';
 import ldsMetadataRefreshEnabled from '@salesforce/gate/lds.metadataRefreshEnabled';
 import graphqlL2AdapterGate from '@salesforce/gate/lmr.graphqlL2Adapter';
+import { isStoreKeyRecordViewEntity as isStoreKeyRecordViewEntity$1, RECORD_ID_PREFIX as RECORD_ID_PREFIX$1, RECORD_FIELDS_KEY_JUNCTION as RECORD_FIELDS_KEY_JUNCTION$1 } from '@salesforce/lds-adapters-uiapi';
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -792,7 +792,7 @@ class DurableTTLStore {
     }
 }
 
-function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStoreErrorHandler, redirects, additionalDurableStoreOperations = [], enableDurableMetadataRefresh = false) {
+function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStoreErrorHandler, redirects, shouldFlush, additionalDurableStoreOperations = [], enableDurableMetadataRefresh = false) {
     const durableRecords = create$7(null);
     const refreshedDurableRecords = create$7(null);
     const evictedRecords = create$7(null);
@@ -820,7 +820,16 @@ function flushInMemoryStoreValuesToDurableStore(store, durableStore, durableStor
         const entries = wasVisited === true || enableDurableMetadataRefresh === false
             ? durableRecords
             : refreshedDurableRecords;
-        setRecordTo(entries, key, record, metadata);
+        const { flushValue: flushValue, forceFlushMetadata: flushMetadata } = shouldFlush(key, record);
+        if (flushValue) {
+            setRecordTo(entries, key, record, metadata);
+        }
+        else {
+            // If the record is not to be flushed, we still need to update the metadata
+            if (flushMetadata === true) {
+                setRecordTo(refreshedDurableRecords, key, record, metadata);
+            }
+        }
     }
     const durableStoreOperations = additionalDurableStoreOperations;
     const recordKeys = keys$8(durableRecords);
@@ -1021,7 +1030,7 @@ function isUnfulfilledSnapshot$1(cachedSnapshotResult) {
  * @param durableStore A DurableStore implementation
  * @param instrumentation An instrumentation function implementation
  */
-function makeDurable(environment, { durableStore, instrumentation, useRevivingStore, enableDurableMetadataRefresh = false, disableDeepFreeze = false, }) {
+function makeDurable(environment, { durableStore, instrumentation, useRevivingStore, shouldFlush, enableDurableMetadataRefresh = false, disableDeepFreeze = false, }) {
     // runtimes can choose to disable deepFreeze, e.g. headless mobile runtime
     setBypassDeepFreeze(disableDeepFreeze);
     let stagingStore = null;
@@ -1228,7 +1237,7 @@ function makeDurable(environment, { durableStore, instrumentation, useRevivingSt
         if (stagingStore === null) {
             return Promise.resolve();
         }
-        const promise = flushInMemoryStoreValuesToDurableStore(stagingStore, durableStore, durableStoreErrorHandler, new Map(pendingStoreRedirects), additionalDurableStoreOperations, enableDurableMetadataRefresh);
+        const promise = flushInMemoryStoreValuesToDurableStore(stagingStore, durableStore, durableStoreErrorHandler, new Map(pendingStoreRedirects), shouldFlush !== null && shouldFlush !== void 0 ? shouldFlush : (() => ({ flushValue: true })), additionalDurableStoreOperations, enableDurableMetadataRefresh);
         pendingStoreRedirects.clear();
         stagingStore = null;
         return promise;
@@ -1607,11 +1616,9 @@ function makeDurable(environment, { durableStore, instrumentation, useRevivingSt
  * For full license text, see the LICENSE.txt file
  */
 
-function isStoreKeyRecordField(key) {
-    return key.indexOf(RECORD_ID_PREFIX) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION) > -1;
-}
-function buildRecordFieldStoreKey$1(recordKey, fieldName) {
-    return `${recordKey}${RECORD_FIELDS_KEY_JUNCTION}${fieldName}`;
+
+function isStoreKeyRecordId$1(key) {
+    return key.indexOf(RECORD_ID_PREFIX) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION) === -1;
 }
 function objectsDeepEqual(lhs, rhs) {
     if (lhs === rhs)
@@ -4482,7 +4489,7 @@ function generateVariableGQLQuery(document, variables) {
  */
 function generateVariableSubQuery(valueNode, name, type, variables) {
     switch (valueNode.kind) {
-        case Kind.OBJECT: {
+        case Kind$1.OBJECT: {
             // For example, `{ Id: { eq: $draftId } }` is a `ObjectValueNode`, which has field keys 'Id'
             const resultQuery = keys$7(valueNode.fields)
                 .map((key) => generateVariableSubQuery(valueNode.fields[key], key, type, variables))
@@ -4493,7 +4500,7 @@ function generateVariableSubQuery(valueNode, name, type, variables) {
             }
             return resultQuery;
         }
-        case Kind.VARIABLE:
+        case Kind$1.VARIABLE:
             return generateVariableNodeQuery(valueNode, name, type, variables);
         default:
             return '';
@@ -4559,7 +4566,7 @@ function swapArgumentWithVariableNodes(swapped, original) {
     });
 }
 function swapValueNodeWithVariableNodes(original, swapped) {
-    if (original.kind === Kind.OBJECT) {
+    if (original.kind === Kind$1.OBJECT) {
         for (const key of keys$7(original.fields)) {
             if (isObjectValueNode$1(swapped) && swapped.fields[key]) {
                 if (is(original.fields[key], 'Variable')) {
@@ -7003,6 +7010,36 @@ function filterOutReferenceFieldsAndLinks(record) {
     return filteredRecords;
 }
 
+/**
+ * Retrieves a denormalized record from the store
+ * NOTE: do no use this if you don't know what you're doing, this can still contain normalized record references
+ * @param recordKey record key
+ * @param durableStore the durable store
+ * @returns a DraftRecordRepresentation containing the requested fields
+ */
+function getDenormalizedRecord(recordKey, durableStore) {
+    return durableStore
+        .getEntries([recordKey], DefaultDurableSegment)
+        .then((entries) => {
+        if (entries === undefined) {
+            return undefined;
+        }
+        const denormalizedEntry = entries[recordKey];
+        if (denormalizedEntry === undefined) {
+            return undefined;
+        }
+        // don't include link information
+        const denormalizedRecord = denormalizedEntry.data;
+        if (isStoreRecordError(denormalizedRecord)) {
+            return undefined;
+        }
+        return denormalizedRecord;
+    });
+}
+function isStoreRecordError(storeRecord) {
+    return storeRecord.__type === 'error';
+}
+
 /**
  * Checks if a resource request is a GET method on the record endpoint
  * @param request the resource request
@@ -7072,7 +7109,7 @@ function getRecordDraftEnvironment(luvio, env, { isDraftId, durableStore }) {
         // if the canonical key matches the key in the resource request it means we do not have a
         // mapping in our cache so either the draft no longer exists in our cache or invalid fields were requested
         if (canonicalKey === recordKey) {
-            const doesDraftExist = (await durableStore.getDenormalizedRecord(recordKey)) !== undefined;
+            const doesDraftExist = (await getDenormalizedRecord(recordKey, durableStore)) !== undefined;
             if (doesDraftExist === false) {
                 return Promise.reject(createNotFoundResponse({
                     message: 'Draft record no longer exists',
@@ -7692,8 +7729,24 @@ function applyReferenceLinksToDraft(record, draftMetadata) {
             continue;
         }
         const { dataType, relationshipName, referenceToInfos } = fieldInfo;
-        const draftFieldValue = record.fields[draftField].value;
+        const draftFieldNode = record.fields[draftField];
+        // JHORST: revisit this logic
+        // do not try to apply drafts on nodes that are pending or missing
+        if (draftFieldNode.__state !== undefined) {
+            if (draftFieldNode.__state.pending === true ||
+                draftFieldNode.__state.isMissing === true)
+                continue;
+        }
+        const draftFieldValue = draftFieldNode.value;
         if (dataType === 'Reference' && relationshipName !== null) {
+            const recordField = record.fields[relationshipName];
+            if (recordField && isFieldLink(recordField)) {
+                const link = recordField.value;
+                // record view entities are not supported by drafts, leave them alone
+                if (isStoreKeyRecordViewEntity(link.__ref)) {
+                    continue;
+                }
+            }
             if (draftFieldValue === null) {
                 recordFields[relationshipName] = {
                     displayValue: null,
@@ -7708,7 +7761,7 @@ function applyReferenceLinksToDraft(record, draftMetadata) {
                 const referencedRecord = referencedRecords.get(key);
                 recordFields[relationshipName] = {
                     displayValue: null,
-                    value: createLink$1(key),
+                    value: createLink(key),
                 };
                 // for custom objects, we select the 'Name' field
                 // otherwise we check the object info for name fields.
@@ -7736,7 +7789,7 @@ function applyReferenceLinksToDraft(record, draftMetadata) {
     }
     return { ...record, fields: recordFields };
 }
-function createLink$1(key) {
+function createLink(key) {
     return { __ref: key };
 }
 function getReferenceInfoForKey(fieldName, field, luvio, objectInfo) {
@@ -7751,7 +7804,7 @@ function getReferenceInfoForKey(fieldName, field, luvio, objectInfo) {
             referenceFieldName: relationshipName,
             field: {
                 displayValue: null,
-                value: createLink$1(key),
+                value: createLink(key),
             },
         };
     }
@@ -7780,7 +7833,6 @@ class UiApiActionHandler extends AbstractResourceRequestActionHandler {
         this.isDraftId = isDraftId;
         this.recordService = recordService;
         this.handlerId = LDS_ACTION_HANDLER_ID;
-        this.collectedFields = create$5(null);
         recordService.registerRecordHandler(this);
     }
     async buildPendingAction(request, queue) {
@@ -7795,7 +7847,7 @@ class UiApiActionHandler extends AbstractResourceRequestActionHandler {
             // to use. We just need to know if we have this record, we don't care about what fields
             // are on this record. This can go away if we wrote a special getRecord adapter which
             // allowed us to get a record with the fields we have cached (i.e. would never go to the network)
-            const doesRecordExist = (await this.durableStore.getDenormalizedRecord(tag)) !== undefined;
+            const doesRecordExist = (await getDenormalizedRecord(tag, this.durableStore)) !== undefined;
             if (!doesRecordExist) {
                 // we are trying to patch or delete a record that we don't have cached. This is not supported.
                 // we'll do one last ditch effort to fetch the record with just the Id field in case we're online.
@@ -8030,7 +8082,7 @@ class UiApiActionHandler extends AbstractResourceRequestActionHandler {
             }
             return filterOutReferenceFieldsAndLinks(recordWithDrafts);
         }
-        const record = await this.durableStore.getDenormalizedRecord(key);
+        const record = await getDenormalizedRecord(key, this.durableStore);
         if (record === undefined) {
             // error - it is an invariant that all drafts have a corresponding record in the store
             throw Error('Could not find record that draft was applied to in the durable store');
@@ -8042,48 +8094,13 @@ class UiApiActionHandler extends AbstractResourceRequestActionHandler {
         return filterOutReferenceFieldsAndLinks(recordWithDrafts);
     }
     applyDraftsToIncomingData(key, data, draftMetadata, publishData) {
-        if (isField(key)) {
-            this.collectedFields[key] = data;
-            return publishData(key, data);
-        }
-        // otherwise we're a record
         if (draftMetadata === undefined) {
-            // no drafts applied to this record, publish and be done
-            this.collectedFields = create$5(null);
             return publishData(key, data);
         }
-        // create a denormalized record with the collected fields
-        const recordFieldNames = keys$5(data.fields);
-        const partialRecord = {
-            ...data,
-            fields: {},
-        };
-        for (const fieldName of recordFieldNames) {
-            const collectedField = this.collectedFields[buildRecordFieldStoreKey$1(key, fieldName)];
-            if (collectedField !== undefined) {
-                partialRecord.fields[fieldName] =
-                    collectedField;
-            }
-        }
-        const recordWithDrafts = replayDraftsOnRecord(partialRecord, draftMetadata);
+        const recordWithDrafts = replayDraftsOnRecord(data, draftMetadata);
         const recordWithSpanningRefLinks = applyReferenceLinksToDraft(recordWithDrafts, draftMetadata);
-        // publish the normalized fields
-        const normalizedRecord = {
-            ...recordWithSpanningRefLinks,
-            ...data,
-            fields: { ...data.fields },
-            lastModifiedDate: recordWithDrafts.lastModifiedDate,
-            lastModifiedById: recordWithDrafts.lastModifiedById,
-        };
-        for (const fieldName of keys$5(recordWithSpanningRefLinks.fields)) {
-            const fieldKey = buildRecordFieldStoreKey$1(key, fieldName);
-            normalizedRecord.fields[fieldName] = { __ref: fieldKey };
-            publishData(fieldKey, recordWithSpanningRefLinks.fields[fieldName]);
-        }
         // publish the normalized record
-        publishData(key, normalizedRecord);
-        // we've published the record, now clear the collected fields
-        this.collectedFields = create$5(null);
+        publishData(key, recordWithSpanningRefLinks);
     }
     updateMetadata(existingMetadata, incomingMetadata) {
         // ensure the the api name cannot be overwritten in the incoming metadata
@@ -8098,7 +8115,7 @@ class UiApiActionHandler extends AbstractResourceRequestActionHandler {
             return request.body.apiName;
         }
         // otherwise we'll read it from the durable store if we can
-        const record = await this.durableStore.getDenormalizedRecord(recordKey);
+        const record = await getDenormalizedRecord(recordKey, this.durableStore);
         if (record !== undefined) {
             return record.apiName;
         }
@@ -8203,9 +8220,6 @@ class UiApiActionHandler extends AbstractResourceRequestActionHandler {
         };
     }
 }
-function isField(key, data) {
-    return isStoreKeyRecordField(key);
-}
 // true if `createable/updateable` property of backdating field is true and draft does not include that fields. If the customer specifies
 // `LastModifiedDate`, it is not overwritten.
 function isBackdatingFieldEditable(objectInfo, backdatingFieldName, attributeName, draftActionFieldNames) {
@@ -8257,6 +8271,36 @@ function performQuickActionDraftEnvironment(luvio, env, handler) {
     });
 }
 
+const PERFORM_UPDATE_RECORD_QUICK_ACTION_ENDPOINT_REGEX = /^\/ui-api\/actions\/perform-quick-action\/.*$/;
+/**
+ * Checks if a provided resource request is a PATCH operation on the record
+ * endpoint. If so, it returns true indicating that the request should be enqueued instead of
+ * hitting the network.
+ * @param request the resource request
+ */
+function isRequestPerformUpdateRecordQuickAction(request) {
+    const { basePath, method } = request;
+    return method === 'patch' && PERFORM_UPDATE_RECORD_QUICK_ACTION_ENDPOINT_REGEX.test(basePath);
+}
+function performUpdateRecordQuickActionDraftEnvironment(luvio, env, handler) {
+    const dispatchResourceRequest = async function (request, context, eventObservers) {
+        if (isRequestPerformUpdateRecordQuickAction(request) === false) {
+            // only override requests to createRecord endpoint
+            return env.dispatchResourceRequest(request, context, eventObservers);
+        }
+        const { data } = await handler.enqueue(request).catch((err) => {
+            throw createDraftSynthesisErrorResponse(normalizeError$1(err).message);
+        });
+        if (data === undefined) {
+            return Promise.reject(createDraftSynthesisErrorResponse());
+        }
+        return createOkResponse(data);
+    };
+    return create$5(env, {
+        dispatchResourceRequest: { value: dispatchResourceRequest },
+    });
+}
+
 class UiApiDraftRecordService {
     constructor(draftQueue, getLuvio, durableStore, objectInfoAdapter, generateId, userId, formatDisplayValue) {
         this.recordEffectingHandlers = {};
@@ -8339,7 +8383,7 @@ class UiApiDraftRecordService {
                 const key = getRecordKeyForId(this.getLuvio(), id);
                 if (referenceMap.has(key) === false &&
                     !referenceFields.some((refInfo) => refInfo.id === id)) {
-                    const record = await this.durableStore.getDenormalizedRecord(key);
+                    const record = await getDenormalizedRecord(key, this.durableStore);
                     if (record !== undefined) {
                         referenceMap.set(key, record);
                     }
@@ -8512,6 +8556,132 @@ class QuickActionExecutionRepresentationHandler extends AbstractResourceRequestA
     }
 }
 
+const UPDATE_RECORD_QUICK_ACTION_HANDLER = 'UPDATE_RECORD_QUICK_ACTION_HANDLER';
+class UpdateRecordQuickActionExecutionRepresentationHandler extends AbstractResourceRequestActionHandler {
+    constructor(getLuvio, draftRecordService, draftQueue, networkAdapter, durableStore, isDraftId) {
+        super(draftQueue, networkAdapter, getLuvio);
+        this.draftRecordService = draftRecordService;
+        this.durableStore = durableStore;
+        this.isDraftId = isDraftId;
+        this.handlerId = UPDATE_RECORD_QUICK_ACTION_HANDLER;
+        this.getDenormedRecord = (key) => {
+            return getDenormalizedRecord(key, this.durableStore);
+        };
+        draftRecordService.registerRecordHandler(this);
+    }
+    draftActionToDraftOperation(queueEntry) {
+        return [
+            {
+                type: 'update',
+                fields: queueEntry.data.body.fields,
+                apiName: queueEntry.data.body.apiName,
+                draftActionId: queueEntry.id,
+                id: queueEntry.targetId,
+                timestamp: queueEntry.timestamp,
+            },
+        ];
+    }
+    async handleActionEnqueued(action) {
+        // as a side effect of enqueueing an action we have to synthesize
+        // edits to the record in the cache
+        const key = action.tag;
+        const record = await this.getDenormedRecord(key);
+        const draftMetadata = await this.getDraftMetadata(key);
+        const recordWithDrafts = replayDraftsOnRecord(record, draftMetadata);
+        const objectInfo = draftMetadata && draftMetadata.objectInfos.get(recordWithDrafts.apiName);
+        //////
+        // This operation is meant to remove any spanning fields from
+        // the record prior to ingestion
+        if (draftMetadata !== undefined && objectInfo !== undefined) {
+            const fieldNames = keys$5(recordWithDrafts.fields);
+            const fieldsCount = keys$5(fieldNames).length;
+            let newFields = {};
+            for (let i = 0; i < fieldsCount; i++) {
+                const field = objectInfo.fields[fieldNames[i]];
+                if (field !== undefined) {
+                    newFields[fieldNames[i]] = recordWithDrafts.fields[fieldNames[i]];
+                }
+            }
+            recordWithDrafts.fields = newFields;
+        }
+        //////
+        await this.ingestResponses([
+            {
+                response: recordWithDrafts,
+                buildCacheKeysForResponse: this.draftRecordService.buildCacheKeysForRecordRepresentation.bind(this.draftRecordService),
+                synchronousIngest: this.draftRecordService.synchronousIngestRecord.bind(this.draftRecordService),
+            },
+        ], action);
+        return super.handleActionEnqueued(action);
+    }
+    canHandlePublish(_key) {
+        return false;
+    }
+    canRepresentationContainDraftMetadata(_representationName) {
+        return false;
+    }
+    getIdFromRequest(request) {
+        const contextId = request.body.contextId;
+        if (typeof contextId !== 'string') {
+            throw Error('contextId not found in request body');
+        }
+        return Promise.resolve(contextId);
+    }
+    getIdFromResponseBody(responseBody) {
+        return responseBody.id;
+    }
+    buildTagForTargetId(id) {
+        return `UiApi::RecordRepresentation:${id}`;
+    }
+    getDataForAction(action) {
+        let contextId = action.data.body.contextId;
+        // populate contextId with user id if not supplied in the body
+        if (contextId === undefined) {
+            contextId = this.draftRecordService.getUserId();
+        }
+        return Promise.resolve({
+            contextId,
+            eTag: 'draft',
+            feedItemId: '',
+            id: action.targetId,
+            isCreated: false,
+            isSuccess: true,
+            successMessage: `record updated.`,
+        });
+    }
+    async getDraftMetadata(key) {
+        const recordId = extractRecordIdFromStoreKey(key);
+        if (recordId === undefined) {
+            return undefined;
+        }
+        const status = await this.draftRecordService.getRecordDraftMetadata(recordId, undefined);
+        return status && status.data;
+    }
+    applyDraftsToIncomingData(key, data, _draftMetadata, publishFn) {
+        publishFn(key, data);
+    }
+    async handleActionRemoved(action) {
+        await this.evictKey(action.tag);
+    }
+    async handleActionCompleted(action, _queueOperations, _allHandlers) {
+        const luvio = this.getLuvio();
+        await luvio.notifyStoreUpdateAvailable([action.tag]);
+    }
+    buildCacheKeysFromResponse(_response) {
+        return new StoreKeyMap();
+    }
+    synchronousIngest(response) {
+        const luvio = this.getLuvio();
+        const key = keyBuilderQuickActionExecutionRepresentation(luvio, {
+            id: response.id,
+        });
+        luvio.storeIngest(key, ingestQuickActionExecutionRepresentation, response);
+    }
+    mergeRequestBody() {
+        throw Error('mergeActions not supported for QuickActionExecutionRepresentationHandler');
+    }
+}
+
 const CONTENT_DOCUMENT_DRAFT_ID_KEY = 'CONTENT_DOCUMENT_DRAFT_ID';
 const CONTENT_VERSION_DRAFT_ID_KEY = 'CONTENT_VERSION_DRAFT_ID';
 const CONTENT_DOCUMENT_LINK_DRAFT_ID_KEY = 'CONTENT_DOCUMENT_LINK_DRAFT_ID';
@@ -9075,389 +9245,6 @@ function deleteRecordDraftAdapterFactory(luvio, actionHandler) {
     };
 }
 
-/**
- * Copyright (c) 2022, Salesforce, Inc.,
- * All rights reserved.
- * For full license text, see the LICENSE.txt file
- */
-
-
-const { keys: keys$4, values: values$2, create: create$4, assign: assign$4, freeze, entries: entries$4 } = Object;
-
-function buildRecordFieldStoreKey(recordKey, fieldName) {
-    return `${recordKey}${RECORD_FIELDS_KEY_JUNCTION$1}${fieldName}`;
-}
-function isStoreKeyRecordId(key) {
-    return key.indexOf(RECORD_ID_PREFIX$1) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION$1) === -1;
-}
-function createLink(key) {
-    return { __ref: key };
-}
-function isStoreRecordError(storeRecord) {
-    return storeRecord.__type === 'error';
-}
-function isEntryDurableRecordRepresentation(entry, key) {
-    // Either a DurableRecordRepresentation or StoreRecordError can live at a record key
-    return ((isStoreKeyRecordId(key) || isStoreKeyRecordViewEntity(key)) &&
-        entry.data.__type === undefined);
-}
-/**
- * Records are stored in the durable store with scalar fields denormalized. This function takes that denoramlized
- * durable store record representation and normalizes it back out into the format the the luvio store expects it
- * @param key Record store key
- * @param entry Durable entry containing a denormalized record representation
- * @returns a set of entries containing the normalized record and its normalized fields
- */
-function normalizeRecordFields(key, entry) {
-    const { data: record } = entry;
-    const { fields, links } = record;
-    const missingFieldLinks = keys$4(links);
-    const fieldNames = keys$4(fields);
-    const normalizedFields = {};
-    const returnEntries = {};
-    // restore fields
-    for (let i = 0, len = fieldNames.length; i < len; i++) {
-        const fieldName = fieldNames[i];
-        const field = fields[fieldName];
-        const fieldKey = buildRecordFieldStoreKey(key, fieldName);
-        returnEntries[fieldKey] = { data: field };
-        normalizedFields[fieldName] = createLink(fieldKey);
-    }
-    // restore missing fields
-    for (let i = 0, len = missingFieldLinks.length; i < len; i++) {
-        const fieldName = missingFieldLinks[i];
-        const link = links[fieldName];
-        if (link.isMissing === true) {
-            normalizedFields[fieldName] = { ...link, __ref: undefined };
-        }
-    }
-    returnEntries[key] = {
-        data: assign$4(record, { fields: normalizedFields }),
-        metadata: entry.metadata,
-    };
-    return returnEntries;
-}
-/**
- * Transforms a record for storage in the durable store. The transformation involves denormalizing
- * scalar fields and persisting link metadata to transform back into a normalized representation
- *
- * If the record contains pending fields this will return undefined as pending records do not get persisted
- * to the durable store. There should be a refresh operation outbound that will bring in the updated record.
- *
- * @param normalizedRecord Record containing normalized field links
- * @param recordStore a store containing referenced record fields
- */
-function buildDurableRecordRepresentation(normalizedRecord, records, pendingEntries, store) {
-    const fields = normalizedRecord.fields;
-    const filteredFields = {};
-    const links = {};
-    const fieldNames = keys$4(fields);
-    for (let i = 0, len = fieldNames.length; i < len; i++) {
-        const fieldName = fieldNames[i];
-        const field = fields[fieldName];
-        // pending fields get filtered out of the durable store
-        const { pending } = field;
-        if (pending === true) {
-            // do not write records with pending fields to the durable store
-            // there should be a refresh operation outbound that will bring in the updated record
-            return undefined;
-        }
-        const { __ref } = field;
-        if (__ref !== undefined) {
-            let ref = records[__ref];
-            if (pendingEntries !== undefined) {
-                // If the ref was part of the pending write that takes precedence
-                const pendingEntry = pendingEntries[__ref];
-                if (pendingEntry !== undefined) {
-                    ref = pendingEntry.data;
-                }
-            }
-            // if field reference exists then add it to our filteredFields
-            if (ref !== undefined) {
-                filteredFields[fieldName] = ref;
-            }
-            else {
-                // if we have a store to read, try to find the field there too
-                // The durable ingest staging store may pass through to L1, and
-                // not all fields are necessarily published every time, so it is
-                // important to check L1 and not just the fields being published,
-                // otherwise we risk truncating the fields on the record.
-                if (store) {
-                    ref = store.readEntry(__ref);
-                    if (ref !== undefined) {
-                        filteredFields[fieldName] = ref;
-                    }
-                }
-            }
-        }
-        // we want to preserve fields that are missing nodes
-        if (field.isMissing === true) {
-            links[fieldName] = field;
-        }
-    }
-    return {
-        ...normalizedRecord,
-        fields: filteredFields,
-        links,
-    };
-}
-function getDenormalizedKey(originalKey, recordId, luvio) {
-    // this will likely need to be handled when moving to structured keys
-    // note record view entities dont have an associated keybuilder. They get ingested as records to a different key format
-    // see the override for how they are handled packages/lds-adapters-uiapi/src/raml-artifacts/types/RecordRepresentation/keyBuilderFromType.ts
-    if (originalKey.startsWith(RECORD_VIEW_ENTITY_ID_PREFIX)) {
-        return RECORD_VIEW_ENTITY_ID_PREFIX + recordId;
-    }
-    return keyBuilderRecord$1(luvio, { recordId });
-}
-function makeRecordDenormalizingDurableStore(luvio, durableStore, getStoreRecords, getStoreMetadata, getStore, sqlStore) {
-    const getEntries = function (entries, segment) {
-        // this HOF only inspects records in the default segment
-        if (segment !== DefaultDurableSegment) {
-            return durableStore.getEntries(entries, segment);
-        }
-        const { length: entriesLength } = entries;
-        if (entriesLength === 0) {
-            return Promise.resolve({});
-        }
-        // filter out record field keys
-        const filteredEntryIds = [];
-        // map of records to avoid requesting duplicate record keys when requesting both records and fields
-        const recordEntries = {};
-        const recordViewEntries = {};
-        for (let i = 0, len = entriesLength; i < len; i++) {
-            const id = entries[i];
-            const recordId = extractRecordIdFromStoreKey$1(id);
-            if (recordId !== undefined) {
-                if (id.startsWith(RECORD_VIEW_ENTITY_ID_PREFIX)) {
-                    if (recordViewEntries[recordId] === undefined) {
-                        const key = getDenormalizedKey(id, recordId, luvio);
-                        recordViewEntries[recordId] = true;
-                        filteredEntryIds.push(key);
-                    }
-                }
-                else {
-                    if (recordEntries[recordId] === undefined) {
-                        const key = getDenormalizedKey(id, recordId, luvio);
-                        recordEntries[recordId] = true;
-                        filteredEntryIds.push(key);
-                    }
-                }
-            }
-            else {
-                filteredEntryIds.push(id);
-            }
-        }
-        // call base getEntries
-        return durableStore.getEntries(filteredEntryIds, segment).then((durableEntries) => {
-            if (durableEntries === undefined) {
-                return undefined;
-            }
-            const returnEntries = create$4(null);
-            const keys$1 = keys$4(durableEntries);
-            for (let i = 0, len = keys$1.length; i < len; i++) {
-                const key = keys$1[i];
-                const value = durableEntries[key];
-                if (value === undefined) {
-                    continue;
-                }
-                if (isEntryDurableRecordRepresentation(value, key)) {
-                    assign$4(returnEntries, normalizeRecordFields(key, value));
-                }
-                else {
-                    returnEntries[key] = value;
-                }
-            }
-            return returnEntries;
-        });
-    };
-    const denormalizeEntries = function (entries) {
-        let hasEntries = false;
-        let hasMetadata = false;
-        const putEntries = create$4(null);
-        const putMetadata = create$4(null);
-        const keys$1 = keys$4(entries);
-        const putRecords = {};
-        const putRecordViews = {};
-        const storeRecords = getStoreRecords !== undefined ? getStoreRecords() : {};
-        const storeMetadata = getStoreMetadata !== undefined ? getStoreMetadata() : {};
-        const store = getStore();
-        for (let i = 0, len = keys$1.length; i < len; i++) {
-            const key = keys$1[i];
-            let value = entries[key];
-            const recordId = extractRecordIdFromStoreKey$1(key);
-            // do not put normalized field values
-            if (recordId !== undefined) {
-                const isRecordView = key.startsWith(RECORD_VIEW_ENTITY_ID_PREFIX);
-                if (isRecordView) {
-                    if (putRecordViews[recordId] === true) {
-                        continue;
-                    }
-                }
-                else {
-                    if (putRecords[recordId] === true) {
-                        continue;
-                    }
-                }
-                const recordKey = getDenormalizedKey(key, recordId, luvio);
-                const recordEntries = entries;
-                const entry = recordEntries[recordKey];
-                let record = entry && entry.data;
-                if (record === undefined) {
-                    record = storeRecords[recordKey];
-                    if (record === undefined) {
-                        // fields are being published without a record for them existing,
-                        // fields cannot exist standalone in the durable store
-                        continue;
-                    }
-                }
-                if (isRecordView) {
-                    putRecordViews[recordId] = true;
-                }
-                else {
-                    putRecords[recordId] = true;
-                }
-                if (isStoreRecordError(record)) {
-                    hasEntries = true;
-                    putEntries[recordKey] = value;
-                    continue;
-                }
-                let metadata = entry && entry.metadata;
-                if (metadata === undefined) {
-                    metadata = {
-                        ...storeMetadata[recordKey],
-                        metadataVersion: DURABLE_METADATA_VERSION,
-                    };
-                }
-                const denormalizedRecord = buildDurableRecordRepresentation(record, storeRecords, recordEntries, store);
-                if (denormalizedRecord !== undefined) {
-                    hasEntries = true;
-                    putEntries[recordKey] = {
-                        data: denormalizedRecord,
-                        metadata,
-                    };
-                    // if undefined then it is pending
-                    // we should still update metadata on pending records
-                }
-                else {
-                    hasMetadata = true;
-                    metadata.expirationTimestamp = metadata.ingestionTimestamp;
-                    putMetadata[recordKey] = {
-                        metadata,
-                    };
-                }
-            }
-            else {
-                hasEntries = true;
-                putEntries[key] = value;
-            }
-        }
-        return { putEntries, putMetadata, hasEntries, hasMetadata };
-    };
-    const setEntries = function (entries, segment) {
-        if (segment !== DefaultDurableSegment) {
-            return durableStore.setEntries(entries, segment);
-        }
-        const { putEntries, putMetadata, hasEntries, hasMetadata } = denormalizeEntries(entries);
-        const promises = [
-            hasEntries ? durableStore.setEntries(putEntries, segment) : undefined,
-        ];
-        if (sqlStore !== undefined && sqlStore.isBatchUpdateSupported()) {
-            promises.push(hasMetadata && sqlStore !== undefined
-                ? durableStore.setMetadata(putMetadata, segment)
-                : undefined);
-        }
-        return Promise.all(promises).then(() => { });
-    };
-    const batchOperations = function (operations) {
-        const operationsWithDenormedRecords = [];
-        for (let i = 0, len = operations.length; i < len; i++) {
-            const operation = operations[i];
-            if (operation.type === 'setMetadata') {
-                // if setMetadata also contains entry data then it needs to be denormalized.
-                const keys$1 = keys$4(operation.entries);
-                if (keys$1.length > 0) {
-                    const firstKey = keys$1[0];
-                    // casted to any to check if data exists
-                    const firstEntry = operation.entries[firstKey];
-                    // it is not possible for setMetadata to contain entries with both data and no data in the same operation.
-                    // this is determined by the plugin supporting update batch calls before it gets to this HOF.
-                    // so we only need to check one entry to confirm this for performance
-                    if (firstEntry.data !== undefined) {
-                        const { putEntries, putMetadata, hasMetadata } = denormalizeEntries(operation.entries);
-                        operationsWithDenormedRecords.push({
-                            ...operation,
-                            entries: putEntries,
-                        });
-                        if (hasMetadata &&
-                            sqlStore !== undefined &&
-                            sqlStore.isBatchUpdateSupported() === true) {
-                            operationsWithDenormedRecords.push({
-                                ...operation,
-                                entries: putMetadata,
-                                type: 'setMetadata',
-                            });
-                        }
-                    }
-                    else {
-                        operationsWithDenormedRecords.push(operation);
-                    }
-                }
-                continue;
-            }
-            if (operation.segment !== DefaultDurableSegment || operation.type === 'evictEntries') {
-                operationsWithDenormedRecords.push(operation);
-                continue;
-            }
-            const { putEntries, putMetadata, hasMetadata } = denormalizeEntries(operation.entries);
-            operationsWithDenormedRecords.push({
-                ...operation,
-                entries: putEntries,
-            });
-            if (hasMetadata &&
-                sqlStore !== undefined &&
-                sqlStore.isBatchUpdateSupported() === true) {
-                operationsWithDenormedRecords.push({
-                    ...operation,
-                    entries: putMetadata,
-                    type: 'setMetadata',
-                });
-            }
-        }
-        return durableStore.batchOperations(operationsWithDenormedRecords);
-    };
-    /**
-     * Retrieves a denormalized record from the store
-     * NOTE: do no use this if you don't know what you're doing, this can still contain normalized record references
-     * @param recordKey record key
-     * @param durableStore the durable store
-     * @returns a DraftRecordRepresentation containing the requested fields
-     */
-    const getDenormalizedRecord = function (recordKey) {
-        return durableStore.getEntries([recordKey], DefaultDurableSegment).then((entries) => {
-            if (entries === undefined) {
-                return undefined;
-            }
-            const denormalizedEntry = entries[recordKey];
-            if (denormalizedEntry === undefined) {
-                return undefined;
-            }
-            // don't include link information
-            const denormalizedRecord = denormalizedEntry.data;
-            if (isStoreRecordError(denormalizedRecord)) {
-                return undefined;
-            }
-            return denormalizedRecord;
-        });
-    };
-    return create$4(durableStore, {
-        getEntries: { value: getEntries, writable: true },
-        setEntries: { value: setEntries, writable: true },
-        batchOperations: { value: batchOperations, writable: true },
-        getDenormalizedRecord: { value: getDenormalizedRecord, writable: true },
-    });
-}
-
 function serializeFieldArguments(argumentNodes, variables) {
     const mutableArgumentNodes = Object.assign([], argumentNodes);
     return `args__(${mutableArgumentNodes
@@ -9570,6 +9357,69 @@ function getOperationFromDocument(document, operationName) {
     return operations[0]; // If a named operation is not provided, we return the first one
 }
 
+/**
+ * The set of allowed kind values for AST nodes.
+ */
+var Kind = Object.freeze({
+  // Name
+  NAME: 'Name',
+  // Document
+  DOCUMENT: 'Document',
+  OPERATION_DEFINITION: 'OperationDefinition',
+  VARIABLE_DEFINITION: 'VariableDefinition',
+  SELECTION_SET: 'SelectionSet',
+  FIELD: 'Field',
+  ARGUMENT: 'Argument',
+  // Fragments
+  FRAGMENT_SPREAD: 'FragmentSpread',
+  INLINE_FRAGMENT: 'InlineFragment',
+  FRAGMENT_DEFINITION: 'FragmentDefinition',
+  // Values
+  VARIABLE: 'Variable',
+  INT: 'IntValue',
+  FLOAT: 'FloatValue',
+  STRING: 'StringValue',
+  BOOLEAN: 'BooleanValue',
+  NULL: 'NullValue',
+  ENUM: 'EnumValue',
+  LIST: 'ListValue',
+  OBJECT: 'ObjectValue',
+  OBJECT_FIELD: 'ObjectField',
+  // Directives
+  DIRECTIVE: 'Directive',
+  // Types
+  NAMED_TYPE: 'NamedType',
+  LIST_TYPE: 'ListType',
+  NON_NULL_TYPE: 'NonNullType',
+  // Type System Definitions
+  SCHEMA_DEFINITION: 'SchemaDefinition',
+  OPERATION_TYPE_DEFINITION: 'OperationTypeDefinition',
+  // Type Definitions
+  SCALAR_TYPE_DEFINITION: 'ScalarTypeDefinition',
+  OBJECT_TYPE_DEFINITION: 'ObjectTypeDefinition',
+  FIELD_DEFINITION: 'FieldDefinition',
+  INPUT_VALUE_DEFINITION: 'InputValueDefinition',
+  INTERFACE_TYPE_DEFINITION: 'InterfaceTypeDefinition',
+  UNION_TYPE_DEFINITION: 'UnionTypeDefinition',
+  ENUM_TYPE_DEFINITION: 'EnumTypeDefinition',
+  ENUM_VALUE_DEFINITION: 'EnumValueDefinition',
+  INPUT_OBJECT_TYPE_DEFINITION: 'InputObjectTypeDefinition',
+  // Directive Definitions
+  DIRECTIVE_DEFINITION: 'DirectiveDefinition',
+  // Type System Extensions
+  SCHEMA_EXTENSION: 'SchemaExtension',
+  // Type Extensions
+  SCALAR_TYPE_EXTENSION: 'ScalarTypeExtension',
+  OBJECT_TYPE_EXTENSION: 'ObjectTypeExtension',
+  INTERFACE_TYPE_EXTENSION: 'InterfaceTypeExtension',
+  UNION_TYPE_EXTENSION: 'UnionTypeExtension',
+  ENUM_TYPE_EXTENSION: 'EnumTypeExtension',
+  INPUT_OBJECT_TYPE_EXTENSION: 'InputObjectTypeExtension'
+});
+/**
+ * The enum type representing the possible kind values of AST nodes.
+ */
+
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
  * All rights reserved.
@@ -9712,7 +9562,7 @@ function isArrayLike(x) {
         (x.length === 0 || (x.length > 0 && Object.prototype.hasOwnProperty.call(x, x.length - 1))));
 }
 
-const { create: create$3, keys: keys$3, values: values$1, entries: entries$3, assign: assign$3 } = Object;
+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 { isArray: isArray$1, from: from$1 } = Array;
 
@@ -10066,7 +9916,7 @@ function dateTimePredicate(input, operator, field, alias) {
         return predicate;
     }
     else if (literal !== undefined) {
-        const isAvailableLiteral = values$1(DateLiteral).includes(literal);
+        const isAvailableLiteral = values$2(DateLiteral).includes(literal);
         // eslint-disable-next-line @salesforce/lds/no-error-in-production
         if (!isAvailableLiteral)
             throw new Error(`${literal} is not a valid DateLiteral`);
@@ -10080,7 +9930,7 @@ function dateTimePredicate(input, operator, field, alias) {
 }
 function dateTimeRange(input, op, field, alias) {
     const dateFunction = field.dataType === 'DateTime' ? 'datetime' : 'date';
-    const key = keys$3(input)[0];
+    const key = keys$4(input)[0];
     let operator = op;
     if (operator === '=')
         operator = 'BETWEEN';
@@ -10381,7 +10231,7 @@ function filterToPredicates(where, recordType, alias, objectInfoMap, joins, draf
     if (!where)
         return [];
     let predicates = [];
-    const fields = keys$3(where);
+    const fields = keys$4(where);
     for (const field of fields) {
         if (field === 'and' || field === 'or') {
             predicates.push(processCompoundPredicate(field, where[field], recordType, alias, objectInfoMap, joins));
@@ -10430,7 +10280,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$3(where[field]);
+                const entityNames = keys$4(where[field]);
                 const polyPredicatesGroups = entityNames
                     .filter((entityName) => fieldInfo.referenceToInfos.some((referenceInfo) => referenceInfo.apiName === entityName))
                     .map((entityName) => {
@@ -10460,7 +10310,7 @@ function filterToPredicates(where, recordType, alias, objectInfoMap, joins, draf
         }
         else {
             //`field` match the filedInfo's apiName
-            for (const [op, value] of entries$3(where[field])) {
+            for (const [op, value] of entries$4(where[field])) {
                 const operator = operatorToSql(op);
                 /**
                 Two types ID processing might be needed. Draft ID swapping is optional, which depends on DraftFunctions existence.
@@ -10914,18 +10764,15 @@ function buildQuery(config) {
     const joins = buildJoins(config);
     const predicates = buildPredicates(config);
     const orderBy = buildOrderBy(config);
-    const staleRecordsSql = excludeStaleRecordsGate.isOpen({ fallback: false })
-        ? `AND (
-            json_extract("${config.alias}".metadata, '${JSON_EXTRACT_PATH_INGESTION_TIMESTAMP}') >= ?
-            OR json_extract("${config.alias}".data, '${JSON_EXTRACT_PATH_DRAFTS}') IS NOT NULL
-          )`
-        : '';
     const sql = `
         SELECT "${config.alias}".data
         FROM lds_data "${config.alias}" ${joins.sql}
         WHERE "${config.alias}".key like 'UiApi::RecordRepresentation:%'
           AND json_extract("${config.alias}".data, '${JSON_EXTRACT_PATH_INGESTION_APINAME}') = '${config.alias}'
-          ${staleRecordsSql}
+          AND (
+            json_extract("${config.alias}".metadata, '${JSON_EXTRACT_PATH_INGESTION_TIMESTAMP}') >= ?
+            OR json_extract("${config.alias}".data, '${JSON_EXTRACT_PATH_DRAFTS}') IS NOT NULL
+          )
           ${predicates.sql}
           ${orderBy.sql}
         LIMIT ?
@@ -10937,7 +10784,7 @@ function buildQuery(config) {
     const bindings = [
         // bindings from predicates on joins
         ...joins.bindings,
-        ...(excludeStaleRecordsGate.isOpen({ fallback: false }) ? [config.ingestionTimestamp] : []),
+        config.ingestionTimestamp,
         // where clause and parent scope bindings
         ...predicates.bindings,
         // limit binding
@@ -10951,7 +10798,7 @@ function dedupeJoins(joins) {
     for (const join of joins) {
         deduped[join.alias + join.to] = join;
     }
-    return values$1(deduped);
+    return values$2(deduped);
 }
 function buildJoins(config) {
     let sql = '';
@@ -10967,16 +10814,13 @@ function buildJoins(config) {
         let timestampAdded = false;
         const joinConditions = join.conditions.reduce((conditionAccumulator, condition) => {
             let joined_sql;
-            const joinMetadataTimestamp = excludeStaleRecordsGate.isOpen({ fallback: false })
-                ? ` AND (json_extract("${join.alias}".metadata, '${JSON_EXTRACT_PATH_INGESTION_TIMESTAMP}') >= ? OR json_extract("${join.alias}".data, '${JSON_EXTRACT_PATH_DRAFTS}') IS NOT NULL)`
-                : '';
+            const joinMetadataTimestamp = ` AND (json_extract("${join.alias}".metadata, '${JSON_EXTRACT_PATH_INGESTION_TIMESTAMP}') >= ? OR json_extract("${join.alias}".data, '${JSON_EXTRACT_PATH_DRAFTS}') IS NOT NULL)`;
             // predicate on a value, use the newly joined table
             if ('type' in condition) {
                 const { sql, binding } = predicateToSQL(condition, join.alias);
                 joined_sql = ` AND ${sql}${timestampAdded ? '' : joinMetadataTimestamp}`;
                 bindings.push(...binding);
-                if (excludeStaleRecordsGate.isOpen({ fallback: false }) &&
-                    timestampAdded === false) {
+                if (timestampAdded === false) {
                     bindings.push(config.ingestionTimestamp);
                     timestampAdded = true;
                 }
@@ -10986,8 +10830,7 @@ function buildJoins(config) {
                 const left = ` AND json_extract("${join.to}".data, '${condition.leftPath}')`;
                 const right = `json_extract("${join.alias}".data, '${condition.rightPath}')`;
                 joined_sql = `${left} = ${right}${timestampAdded ? '' : joinMetadataTimestamp}`;
-                if (excludeStaleRecordsGate.isOpen({ fallback: false }) &&
-                    timestampAdded === false) {
+                if (timestampAdded === false) {
                     bindings.push(config.ingestionTimestamp);
                     timestampAdded = true;
                 }
@@ -11041,19 +10884,19 @@ function isObjectValueNode(node) {
     return node.kind === 'ObjectValue';
 }
 function isStringValueNode(node) {
-    return node.kind === Kind.STRING;
+    return node.kind === Kind$1.STRING;
 }
 function isFieldNode(node) {
     return node !== undefined && node.kind !== undefined ? node.kind === 'Field' : false;
 }
 function isFieldOrInlineFragmentNode(node) {
     return node !== undefined && node.kind !== undefined
-        ? node.kind === 'Field' || node.kind === Kind.INLINE_FRAGMENT
+        ? node.kind === 'Field' || node.kind === Kind$1.INLINE_FRAGMENT
         : false;
 }
 function isInlineFragmentNode(node) {
     return node !== undefined && node.kind !== undefined
-        ? node.kind === Kind.INLINE_FRAGMENT
+        ? node.kind === Kind$1.INLINE_FRAGMENT
         : false;
 }
 function isCompoundPredicate(predicate) {
@@ -11257,9 +11100,9 @@ function isCapableRelationship(node) {
 function isScopeArgumentNodeWithType(node, scopeType, variables) {
     if (node.name.value !== 'scope')
         return false;
-    if (node.value.kind !== Kind.ENUM && node.value.kind !== Kind.VARIABLE)
+    if (node.value.kind !== Kind$1.ENUM && node.value.kind !== Kind$1.VARIABLE)
         return false;
-    if (node.value.kind === Kind.ENUM) {
+    if (node.value.kind === Kind$1.ENUM) {
         if (node.value.value === scopeType) {
             return true;
         }
@@ -11366,7 +11209,7 @@ function isInlineFragmentFieldSpanning(node) {
     if (!node.selectionSet)
         return false;
     return node.selectionSet.selections.some((selection) => {
-        if (selection.kind !== Kind.INLINE_FRAGMENT)
+        if (selection.kind !== Kind$1.INLINE_FRAGMENT)
             return false;
         return isFieldSpanning(selection, node);
     });
@@ -11629,7 +11472,7 @@ function depth(json, currentLevel = 0) {
     if (typeof json !== 'object') {
         return currentLevel;
     }
-    const keys$1 = keys$3(json);
+    const keys$1 = keys$4(json);
     if (keys$1.length === 0)
         return 0;
     const depths = keys$1.map((key) => {
@@ -11642,7 +11485,7 @@ function flatten(previous, current) {
     return previous.concat(current);
 }
 function findFieldInfo(objectInfo, fieldName) {
-    return values$1(objectInfo.fields).find((field) => field.apiName === fieldName ||
+    return values$2(objectInfo.fields).find((field) => field.apiName === fieldName ||
         (field.dataType === 'Reference' && field.relationshipName === fieldName));
 }
 async function readIngestionTimestampForKey(key, query) {
@@ -11659,6 +11502,12 @@ async function readIngestionTimestampForKey(key, query) {
     }
     return ingestionTimestamp;
 }
+async function readPaginationMetadataForKey(key, query) {
+    const sql = `SELECT data FROM lds_data WHERE key=?`;
+    const results = await query(sql, [key + '__pagination']);
+    const [paginationMetadata] = results.rows.map((row) => parse$3(row[0]));
+    return paginationMetadata || {};
+}
 
 function findSpanningField(name) {
     return (field) => {
@@ -11672,14 +11521,14 @@ function orderByToPredicate(orderBy, recordType, alias, objectInfoMap, joins) {
         return predicates;
     const isSpanning = depth(orderBy) > 2;
     if (isSpanning) {
-        const keys$1 = keys$3(orderBy);
+        const keys$1 = keys$4(orderBy);
         for (let i = 0, len = keys$1.length; i < len; i++) {
             const key = keys$1[i];
             const parentFields = objectInfoMap[recordType].fields;
-            const fieldInfo = values$1(parentFields).find(findSpanningField(key));
+            const fieldInfo = values$2(parentFields).find(findSpanningField(key));
             if (fieldInfo && fieldInfo.referenceToInfos.length > 0) {
                 const { apiName } = fieldInfo.referenceToInfos[0];
-                const parentFieldInfo = values$1(objectInfoMap[recordType].fields).find(findSpanningField(fieldInfo.apiName));
+                const parentFieldInfo = values$2(objectInfoMap[recordType].fields).find(findSpanningField(fieldInfo.apiName));
                 if (parentFieldInfo !== undefined) {
                     const path = {
                         leftPath: `$.fields.${parentFieldInfo.apiName}.value`,
@@ -11702,7 +11551,7 @@ function orderByToPredicate(orderBy, recordType, alias, objectInfoMap, joins) {
         }
     }
     else {
-        const keys$1 = keys$3(orderBy);
+        const keys$1 = keys$4(orderBy);
         for (let i = 0, len = keys$1.length; i < len; i++) {
             const key = keys$1[i];
             if (!objectInfoMap[recordType])
@@ -11862,21 +11711,23 @@ function cursorResolver(source) {
     return encodeV1Cursor(source.index);
 }
 function pageInfoResolver(source) {
-    if (source.length === 0) {
+    if (source.records.length === 0) {
         return {
             startCursor: null,
             endCursor: null,
+            hasNextPage: false,
         };
     }
-    let startIndex = source[0].index;
-    let endIndex = source[source.length - 1].index;
+    let startIndex = source.records[0].index;
+    let endIndex = source.records[source.records.length - 1].index;
     return {
         startCursor: encodeV1Cursor(startIndex),
         endCursor: encodeV1Cursor(endIndex),
+        hasNextPage: source.hasNextPage,
     };
 }
 function pageResultCountResolver(source) {
-    return source.length;
+    return source.records.length;
 }
 function encodeV1Cursor(index) {
     return base64encode(`v1:${index}`);
@@ -11895,17 +11746,53 @@ function decodeV1Cursor(base64cursor) {
     }
     return Number(found.groups.index);
 }
+/**
+ * Check the selections for any selection matching `pageInfo { hasNextPage }`
+ */
+function selectionIncludesHasNextPage(selections, fragments) {
+    for (let selection of selections) {
+        switch (selection.kind) {
+            case Kind.FIELD: {
+                if (selection.name.value === 'pageInfo') {
+                    if (!selection.selectionSet)
+                        continue;
+                    return selectionIncludesHasNextPage(selection.selectionSet.selections, fragments);
+                }
+                if (selection.name.value === 'hasNextPage') {
+                    return true;
+                }
+                break;
+            }
+            case Kind.FRAGMENT_SPREAD: {
+                let fragment = fragments[selection.name.value];
+                if (!fragment)
+                    return false;
+                if (selectionIncludesHasNextPage(fragment.selectionSet.selections, fragments)) {
+                    return true;
+                }
+                break;
+            }
+            case Kind.INLINE_FRAGMENT:
+                if (selectionIncludesHasNextPage(selection.selectionSet.selections, fragments)) {
+                    return true;
+                }
+                break;
+        }
+    }
+    return false;
+}
 
 /*
 resolves connections...
 */
 async function connectionResolver(obj, args, context, info) {
     let { recordRepresentation: parentRecord, ingestionTimestamp = 0 } = obj;
-    if (!parentRecord && excludeStaleRecordsGate.isOpen({ fallback: false })) {
+    let queryCacheKey = buildKeyStringForRecordQuery(info.operation, info.variableValues, info.fieldNodes[0].arguments || [], info.fieldName);
+    const { query, objectInfos, draftFunctions } = context;
+    if (!parentRecord) {
         // at our record query we fetch each ingestion time stamp and pass it down to each lower resolver to query against
-        ingestionTimestamp = await fetchIngestionTimeStampFromDatabase(info.fieldName, info, args, context.query);
+        ingestionTimestamp = await readIngestionTimestampForKey(queryCacheKey, query);
     }
-    const { query, objectInfos, draftFunctions } = context;
     let joins = [];
     let alias = info.fieldName;
     let childRelationshipFieldName = undefined;
@@ -11917,7 +11804,7 @@ async function connectionResolver(obj, args, context, info) {
             parentObjectInfo.childRelationships.find((rel) => rel.relationshipName === info.fieldName);
         // or emit/throw if we want to report it
         if (!childRelationship)
-            return [];
+            return { records: [], hasNextPage: false };
         alias = childRelationship.childObjectApiName;
         childRelationshipFieldName = childRelationship.fieldName;
     }
@@ -11929,24 +11816,51 @@ async function connectionResolver(obj, args, context, info) {
     ];
     const scopeJoins = scopeToJoins(args.scope, context.settings);
     joins.push(...scopeJoins);
+    // Limit defaults to 10 records if unspecified
+    let limit = 10;
+    if (args.first) {
+        limit = args.first;
+    }
     let offset = 0;
     if (args.after) {
         offset = decodeV1Cursor(args.after) + 1;
     }
+    // if the query wants to know `hasNextPage` then we need to request 1 additional record
+    let selections = info.fieldNodes
+        .map((n) => (n.selectionSet ? n.selectionSet.selections : []))
+        .flat();
+    let wantsHasNextPage = selectionIncludesHasNextPage(selections, info.fragments);
+    let paginationMetadata = undefined;
+    if (wantsHasNextPage) {
+        paginationMetadata = await readPaginationMetadataForKey(queryCacheKey, query);
+    }
+    let internalLimit = limit + (wantsHasNextPage ? 1 : 0);
     // Alias starts as entity's ApiName
     const queryConfig = {
         alias,
         joins,
         predicates,
         orderBy: orderByToPredicate(args.orderBy, alias, alias, context.objectInfos),
-        limit: args.first,
-        offset: offset,
+        limit: internalLimit,
+        offset,
         ingestionTimestamp,
     };
     const { sql, bindings } = buildQuery(queryConfig);
     const results = await query(sql, bindings);
+    let hasNextPage = false;
+    if (wantsHasNextPage) {
+        if (results.rows.length > limit) {
+            // more records exist in the cache
+            hasNextPage = true;
+            results.rows.pop();
+        }
+        else if (!paginationMetadata || paginationMetadata.__END__ === undefined) {
+            // more records may exist on the server
+            hasNextPage = true;
+        }
+    }
     //map each sql result with the ingestion timestamp to pass it down a level
-    return results.rows
+    let records = results.rows
         .map((row) => parse$3(row[0]))
         .map((recordRepresentation, index) => {
         context.seenRecordIds.add(recordRepresentation.id);
@@ -11956,6 +11870,10 @@ async function connectionResolver(obj, args, context, info) {
             index: index + offset,
         };
     });
+    return {
+        records,
+        hasNextPage,
+    };
 }
 /**
  * Converts a childRelationship into a predicate
@@ -11978,26 +11896,10 @@ function childRelationshipToPredicates(childRelationshipFieldName, parentId) {
     return predicates;
 }
 /**
- * fetches a query level ingestion time stamp from the L2 cache
- * if no query has been seen then the timestamp is 0
- * @param apiName
- * @param info
- * @param args
- * @param query
- * @returns
+ * Returns just the records array of a connection result, used for edges field
  */
-async function fetchIngestionTimeStampFromDatabase(apiName, info, args, query) {
-    const { operation, variableValues } = info;
-    // if we cannot find the query key in the database then default to 0 as we assume we have not seen the query
-    // and all the data is not stale
-    let ingestionTimestamp = 0;
-    if (info.fieldNodes.length > 0 && info.fieldNodes[0].arguments !== undefined) {
-        const key = buildKeyStringForRecordQuery(operation, 
-        // join varables passed from query to the argument variables given from the AST
-        { ...variableValues, ...args }, info.fieldNodes[0].arguments, apiName);
-        return readIngestionTimestampForKey(key, query);
-    }
-    return ingestionTimestamp;
+function edgesResolver(obj) {
+    return obj.records;
 }
 /**
  * Builds the top level record query key based on AST data
@@ -12017,7 +11919,7 @@ function buildKeyStringForRecordQuery(operation, variables, argumentNodes, curre
         variables,
         fragmentMap: {},
     });
-    const filteredArgumentNodes = assign$3([], argumentNodes).filter((node) => node.name.value !== 'first' && node.name.value !== 'after');
+    const filteredArgumentNodes = assign$4([], argumentNodes).filter((node) => node.name.value !== 'first' && node.name.value !== 'after');
     const argumentString = filteredArgumentNodes.length > 0
         ? '__' + serializeFieldArguments(filteredArgumentNodes, variables)
         : '';
@@ -12040,7 +11942,7 @@ function addResolversToSchema(schema, polyFields) {
     let baseRecord = undefined;
     // Concrete types for Polymorphic field
     const polyTypes = [];
-    for (const type of values$1(schema.getTypeMap())) {
+    for (const type of values$2(schema.getTypeMap())) {
         if (type.name === 'Record') {
             recordInterface = type;
         }
@@ -12053,7 +11955,7 @@ function addResolversToSchema(schema, polyFields) {
         if (polyFields.find((fieldTypeName) => fieldTypeName === type.name) !== undefined) {
             polyTypes.push(type);
         }
-        const fields = values$1(type.getFields());
+        const fields = values$2(type.getFields());
         // initialize the fields of current type with default behavior
         for (const field of fields) {
             field.resolve = defaultFieldResolver;
@@ -12114,7 +12016,7 @@ function addResolversToSchema(schema, polyFields) {
             for (const field of fields) {
                 switch (field.name) {
                     case 'edges':
-                        field.resolve = passThroughResolver;
+                        field.resolve = edgesResolver;
                         break;
                     case 'pageInfo':
                         field.resolve = pageInfoResolver;
@@ -12432,7 +12334,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$3(objectInfoMap)) {
+    for (const name of keys$4(objectInfoMap)) {
         const objectInfo = objectInfoMap[name];
         const { apiName } = objectInfo;
         const type = schema.getType(apiName);
@@ -12501,7 +12403,7 @@ function createNewRecordQuery(schema, objectInfo, objectInfoMap) {
     const { apiName, childRelationships, fields: fieldsRepresentation } = objectInfo;
     typedScalars.add(`${apiName}_Filter`);
     typedScalars.add(`${apiName}_OrderBy`);
-    const { fields, polymorphicFieldTypeNames } = makeRecordField(values$1(fieldsRepresentation), objectInfo, objectInfoMap, parentRelationshipFields, 'Missing');
+    const { fields, polymorphicFieldTypeNames } = makeRecordField(values$2(fieldsRepresentation), objectInfo, objectInfoMap, parentRelationshipFields, 'Missing');
     // handles child relationship
     const { spanningRecordConnections, typedScalars: spanningConnectionTypedScalars } = makeSpanningRecordConnections(schema, childRelationships, objectInfoMap, parentRelationshipFields);
     typedScalars = new Set([...typedScalars, ...spanningConnectionTypedScalars]);
@@ -12559,8 +12461,8 @@ 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$3(type.getFields());
-    const missingFields = values$1(objectInfo.fields).filter((field) => {
+    const existingFields = keys$4(type.getFields());
+    const missingFields = values$2(objectInfo.fields).filter((field) => {
         return (existingFields.includes(field.apiName) === false ||
             (field.relationshipName !== null && field.referenceToInfos.length > 0));
     });
@@ -12642,7 +12544,7 @@ function makeSpanningRecordConnections(schema, childRelationships, objectInfoMap
 function makeRecordField(fieldRepresentations, objectInfo, objectInfoMap, existingParentRelationships, recordTypeInSchema, existingFields = []) {
     const polymorphicFieldTypeNames = new Set();
     let fields = ``;
-    for (const field of values$1(fieldRepresentations)) {
+    for (const field of values$2(fieldRepresentations)) {
         if (!fieldsStaticallyAdded.includes(field.apiName) && recordTypeInSchema === 'Missing') {
             fields += `${field.apiName}: ${graphqlTypeForField(field, objectInfo)}\n`;
         }
@@ -12860,20 +12762,20 @@ async function evaluate(config, observers, settings, objectInfos, store, snapsho
 }
 
 const parentRelationshipDirective = {
-    kind: Kind.DIRECTIVE,
+    kind: Kind$1.DIRECTIVE,
     name: {
-        kind: Kind.NAME,
+        kind: Kind$1.NAME,
         value: 'category',
     },
     arguments: [
         {
-            kind: Kind.ARGUMENT,
+            kind: Kind$1.ARGUMENT,
             name: {
-                kind: Kind.NAME,
+                kind: Kind$1.NAME,
                 value: 'name',
             },
             value: {
-                kind: Kind.STRING,
+                kind: Kind$1.STRING,
                 value: PARENT_RELATIONSHIP,
                 block: false,
             },
@@ -12881,12 +12783,12 @@ const parentRelationshipDirective = {
     ],
 };
 const FieldValueNodeSelectionSet = {
-    kind: Kind.SELECTION_SET,
+    kind: Kind$1.SELECTION_SET,
     selections: [
         {
-            kind: Kind.FIELD,
+            kind: Kind$1.FIELD,
             name: {
-                kind: Kind.NAME,
+                kind: Kind$1.NAME,
                 value: 'value',
             },
         },
@@ -13147,7 +13049,7 @@ async function injectSyntheticFields(originalAST, objectInfoService, draftFuncti
 }
 function swapIdField(filterFields, objectInfo, swapped, idState, draftFunctions) {
     switch (filterFields.kind) {
-        case Kind.OBJECT: {
+        case Kind$1.OBJECT: {
             const fieldNodes = filterFields.fields.map((fieldNode) => {
                 // check at the object value node level if the node's name is an Id/Reference
                 // if not then just pass the current swapped state
@@ -13165,7 +13067,7 @@ function swapIdField(filterFields, objectInfo, swapped, idState, draftFunctions)
                 fields: fieldNodes,
             };
         }
-        case Kind.STRING: {
+        case Kind$1.STRING: {
             if (!swapped) {
                 return filterFields;
             }
@@ -13184,7 +13086,7 @@ function swapIdField(filterFields, objectInfo, swapped, idState, draftFunctions)
                 block: false,
             };
         }
-        case Kind.LIST: {
+        case Kind$1.LIST: {
             const values = filterFields.values.map((valueNode) => swapIdField(valueNode, objectInfo, swapped, idState, draftFunctions));
             return {
                 kind: 'ListValue',
@@ -13204,7 +13106,7 @@ function isMineScopeAvailable(apiNamePath, pathToObjectApiNamesMap, objectInfos)
     const objectInfo = objectInfos[apiName[0]];
     if (!objectInfo)
         return false;
-    return values$1(objectInfo.fields).some((fieldInfo) => {
+    return values$2(objectInfo.fields).some((fieldInfo) => {
         return (fieldInfo.apiName === 'OwnerId' &&
             fieldInfo.referenceToInfos.some((referenceToInfo) => {
                 return referenceToInfo.apiName === 'User';
@@ -13270,14 +13172,14 @@ function mergeSelectionNodes(group1, group2) {
 function growObjectFieldTree(tree, parentNode, entryNode, totalNodes, startNodes) {
     entryNode.fields.forEach((objectFieldNode) => {
         // objectFieldNode: {Account: { Name : { eq: "xxyyzz"}}}; objectFieldNode.value: { Name : { eq: "xxyyzz"}}
-        if (objectFieldNode.value.kind === Kind.OBJECT) {
+        if (objectFieldNode.value.kind === Kind$1.OBJECT) {
             if (objectFieldNode.name.value === 'not') {
                 // recursively go to deeper level of filter.
                 growObjectFieldTree(tree, parentNode, objectFieldNode.value, totalNodes, startNodes);
             }
             else {
                 // Spanning Field 'Account'
-                if (objectFieldNode.value.fields.some((childObjectFieldNode) => childObjectFieldNode.value.kind === Kind.OBJECT)) {
+                if (objectFieldNode.value.fields.some((childObjectFieldNode) => childObjectFieldNode.value.kind === Kind$1.OBJECT)) {
                     if (!totalNodes.has(parentNode)) {
                         totalNodes.add(parentNode);
                         startNodes.add(parentNode);
@@ -13300,7 +13202,7 @@ function growObjectFieldTree(tree, parentNode, entryNode, totalNodes, startNodes
                 }
             }
         }
-        else if (objectFieldNode.value.kind === Kind.LIST) {
+        else if (objectFieldNode.value.kind === Kind$1.LIST) {
             objectFieldNode.value.values.filter(isObjectValueNode).forEach((childNode) => {
                 growObjectFieldTree(tree, parentNode, childNode, totalNodes, startNodes);
             });
@@ -13414,7 +13316,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$3(objectInfos).length < startNodes.size) {
+    if (keys$4(objectInfos).length < startNodes.size) {
         // eslint-disable-next-line
         throw new Error(`Unable to resolve ObjectInfo(s) for ${Array.from(startNodes)}`);
     }
@@ -13578,7 +13480,7 @@ function injectFilter(filterNode, idState, parentPath, isParentPolymorphic, obje
     const injectedSelections = [];
     let isPolymorphicField = false;
     switch (filterNode.kind) {
-        case Kind.ARGUMENT:
+        case Kind$1.ARGUMENT:
             if (filterNode.value.kind !== 'ObjectValue')
                 return [];
             filterNode.value.fields.forEach((objectFieldNode) => {
@@ -13592,9 +13494,9 @@ function injectFilter(filterNode, idState, parentPath, isParentPolymorphic, obje
                 }
             });
             return injectedSelections;
-        case Kind.OBJECT_FIELD:
+        case Kind$1.OBJECT_FIELD:
             switch (filterNode.value.kind) {
-                case Kind.LIST: {
+                case Kind$1.LIST: {
                     filterNode.value.values.filter(isObjectValueNode).forEach((objectValueNode) => {
                         objectValueNode.fields.forEach((objectFieldNode) => {
                             const subResults = injectFilter(objectFieldNode, idState, parentPath, isParentPolymorphic, objectInfos, pathToObjectApiNamesMap, draftFunctions, queryNode);
@@ -13605,7 +13507,7 @@ function injectFilter(filterNode, idState, parentPath, isParentPolymorphic, obje
                     });
                     return injectedSelections;
                 }
-                case Kind.OBJECT: {
+                case Kind$1.OBJECT: {
                     if (filterNode.name.value === 'not') {
                         filterNode.value.fields.forEach((objectFieldNode) => {
                             const subResults = injectFilter(objectFieldNode, idState, parentPath, isParentPolymorphic, objectInfos, pathToObjectApiNamesMap, draftFunctions, queryNode);
@@ -13735,9 +13637,9 @@ function injectFilter(filterNode, idState, parentPath, isParentPolymorphic, obje
                                 (isInlineFragment && !isTypeNameExisting)) {
                                 if (isInlineFragment) {
                                     sel = {
-                                        kind: Kind.INLINE_FRAGMENT,
+                                        kind: Kind$1.INLINE_FRAGMENT,
                                         typeCondition: {
-                                            kind: Kind.NAMED_TYPE,
+                                            kind: Kind$1.NAMED_TYPE,
                                             name: {
                                                 kind: 'Name',
                                                 value: filterNode.name.value,
@@ -13756,14 +13658,14 @@ function injectFilter(filterNode, idState, parentPath, isParentPolymorphic, obje
                                                 ...sel,
                                                 directives,
                                                 selectionSet: {
-                                                    kind: Kind.SELECTION_SET,
+                                                    kind: Kind$1.SELECTION_SET,
                                                     selections: idField.concat(...subSelectionNodes),
                                                 },
                                             }
                                             : {
                                                 ...sel,
                                                 selectionSet: {
-                                                    kind: Kind.SELECTION_SET,
+                                                    kind: Kind$1.SELECTION_SET,
                                                     selections: idField.concat(...subSelectionNodes),
                                                 },
                                             };
@@ -13892,12 +13794,12 @@ function updateIDInfo(fieldNode, idState, draftFunctions) {
     if (isObjectValueNode(fieldNode.value)) {
         const idOpValueNode = fieldNode.value.fields[0];
         switch (idOpValueNode.value.kind) {
-            case Kind.STRING: {
+            case Kind$1.STRING: {
                 const id = idOpValueNode.value.value;
                 idState.swapNeeded = draftFunctions.isDraftId(id);
                 break;
             }
-            case Kind.LIST: {
+            case Kind$1.LIST: {
                 const listValues = idOpValueNode.value.values;
                 idState.swapNeeded = listValues
                     .filter(isStringValueNode)
@@ -13984,7 +13886,7 @@ function injectParentRelationships(selections, parentNode, parentPath, ancestors
                 parentInjectedNodes.push({
                     ...selection,
                     selectionSet: {
-                        kind: Kind.SELECTION_SET,
+                        kind: Kind$1.SELECTION_SET,
                         selections: [...idSelection, ...subInjectedSelections],
                     },
                 });
@@ -14355,7 +14257,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$3(nodeJson);
+    const keys$1 = keys$4(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
@@ -14375,7 +14277,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$3(jsonInput);
+    const keys$1 = keys$4(jsonInput);
     if (selection.selectionSet) {
         createjsonOutput(selection.selectionSet.selections, jsonInput, jsonOutput);
     }
@@ -14384,7 +14286,7 @@ function createUserJsonOutput(selection, jsonInput, jsonOutput) {
     }
 }
 function createjsonOutput(selections, jsonInput, jsonOutput) {
-    const keys$1 = keys$3(jsonInput);
+    const keys$1 = keys$4(jsonInput);
     selections.filter(isFieldNode).forEach((subSelection) => {
         const fieldName = subSelection.alias ? subSelection.alias.value : subSelection.name.value;
         if (keys$1.includes(fieldName)) {
@@ -14447,9 +14349,9 @@ function referenceIdFieldForRelationship(relationshipName) {
  */
 function createFieldNode(nameValue, selectionSet) {
     return {
-        kind: Kind.FIELD,
+        kind: Kind$1.FIELD,
         name: {
-            kind: Kind.NAME,
+            kind: Kind$1.NAME,
             value: nameValue,
         },
         selectionSet,
@@ -14554,7 +14456,7 @@ const replaceDraftIdsInVariables = (variables, draftFunctions, unmappedDraftIDs)
         }
         else if (typeof object === 'object' && object !== null) {
             let source = object;
-            return keys$3(source).reduce((acc, key) => {
+            return keys$4(source).reduce((acc, key) => {
                 acc[key] = replace(source[key]);
                 return acc;
             }, {});
@@ -14563,7 +14465,7 @@ const replaceDraftIdsInVariables = (variables, draftFunctions, unmappedDraftIDs)
             return object;
         }
     };
-    let newVariables = keys$3(variables).reduce((acc, key) => {
+    let newVariables = keys$4(variables).reduce((acc, key) => {
         acc[key] = replace(variables[key]);
         return acc;
     }, {});
@@ -14949,14 +14851,14 @@ const recordIdGenerator = (id) => {
  */
 
 
-const { keys: keys$2, create: create$2, assign: assign$2, entries: entries$2 } = Object;
+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 { isArray, from } = Array;
 
 function ldsParamsToString(params) {
-    const returnParams = create$2(null);
-    const keys$1 = keys$2(params);
+    const returnParams = create$3(null);
+    const keys$1 = keys$3(params);
     for (let i = 0, len = keys$1.length; i < len; i++) {
         const key = keys$1[i];
         const value = params[key];
@@ -14973,7 +14875,7 @@ function ldsParamsToString(params) {
         else {
             returnParams[key] = `${value}`;
         }
-        if (isObject(value) === true && keys$2(value).length > 0) {
+        if (isObject(value) === true && keys$3(value).length > 0) {
             returnParams[key] = stringify$2(value);
         }
     }
@@ -15374,7 +15276,7 @@ function buildAggregateUiUrl(params, resourceRequest) {
         optionalFields,
     };
     const queryString = [];
-    for (const [key, value] of entries$2(mergedParams)) {
+    for (const [key, value] of entries$3(mergedParams)) {
         if (value !== undefined) {
             queryString.push(`${key}=${isArray(value) ? value.join(',') : value}`);
         }
@@ -15390,7 +15292,7 @@ function isSpanningRecord(fieldValue) {
 function mergeRecordFields(first, second) {
     const { fields: targetFields } = first;
     const { fields: sourceFields } = second;
-    const fieldNames = keys$2(sourceFields);
+    const fieldNames = keys$3(sourceFields);
     for (let i = 0, len = fieldNames.length; i < len; i += 1) {
         const fieldName = fieldNames[i];
         const sourceField = sourceFields[fieldName];
@@ -15554,7 +15456,7 @@ function calculateEstimatedTotalUrlLength(request) {
     const { baseUri, basePath, queryParams } = request;
     let url = `${baseUri}${basePath}`;
     if (queryParams) {
-        const queryParamString = entries$2(queryParams)
+        const queryParamString = entries$3(queryParams)
             .map(([key, value]) => `${key}=${value}`)
             .join('&');
         if (queryParamString) {
@@ -15767,7 +15669,7 @@ function makeNetworkAdapterChunkRecordFields(networkAdapter, instrumentationSink
     }, networkAdapter);
 }
 
-const { keys: keys$1, create: create$1, assign: assign$1, entries: entries$1 } = Object;
+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;
 
@@ -16123,7 +16025,7 @@ function instrumentDraftQueue(queue) {
             logError: false,
         });
     };
-    return create$1(queue, { mergeActions: { value: mergeActions } });
+    return create$2(queue, { mergeActions: { value: mergeActions } });
 }
 
 // so eslint doesn't complain about nimbus
@@ -16202,7 +16104,7 @@ function enableObjectInfoCaching(env, ensureObjectInfoCached) {
     function dataIsObjectInfo(key, data) {
         return incomingObjectInfos.has(key);
     }
-    return create$1(env, {
+    return create$2(env, {
         handleSuccessResponse: { value: handleSuccessResponse },
         storePublish: { value: storePublish },
     });
@@ -16213,10 +16115,11 @@ Builds adapter instances for environments that have cross-adapter dependencies.
 These are only to be used internally in this module and not exported.
 They do not use draft environments, just the makeDurable environment.
 */
-function buildInternalAdapters(store, networkAdapter, durableStore, ensureObjectInfoCached) {
+function buildInternalAdapters(store, networkAdapter, durableStore, ensureObjectInfoCached, shouldFlush) {
     const baseEnv = new Environment(store, networkAdapter);
     const durableEnvironment = makeDurable(baseEnv, {
         durableStore,
+        shouldFlush,
     });
     const objectInfoCachingEnvionment = enableObjectInfoCaching(durableEnvironment, ensureObjectInfoCached);
     const luvio = new Luvio(objectInfoCachingEnvionment);
@@ -16302,8 +16205,8 @@ class ObjectInfoService {
             }
         };
         // Local in-memory cache for apiName to key prefixes
-        this.apiNameToKeyPrefixMemoryCache = create$1(null);
-        this.keyPrefixToApiNameMemoryCache = create$1(null);
+        this.apiNameToKeyPrefixMemoryCache = create$2(null);
+        this.keyPrefixToApiNameMemoryCache = create$2(null);
     }
     /**
      * Size of return map not necessarily correlated with number of inputs.  The
@@ -16447,7 +16350,7 @@ function registerReportObserver(reportObserver) {
     };
 }
 
-const { keys, create, assign, entries, values } = Object;
+const { keys: keys$1, create: create$1, assign: assign$1, entries: entries$1, values: values$1 } = Object;
 const { stringify, parse } = JSON;
 
 function selectColumnsFromTableWhereKeyIn(columnNames, table, keyColumnName, whereIn) {
@@ -16514,7 +16417,7 @@ class LdsDataTable {
             },
             conflictColumns: this.conflictColumnNames,
             columns: this.columnNames,
-            rows: keys(entries).reduce((rows, key) => {
+            rows: keys$1(entries).reduce((rows, key) => {
                 const entry = entries[key];
                 const { data, metadata } = entry;
                 const row = [key, stringify(data), metadata ? stringify(metadata) : null];
@@ -16533,7 +16436,7 @@ class LdsDataTable {
                 type: 'setMetadata',
             },
             columns: [COLUMN_NAME_METADATA$1],
-            values: keys(entries).reduce((values, key) => {
+            values: keys$1(entries).reduce((values, key) => {
                 const { metadata } = entries[key];
                 const row = [metadata ? stringify(metadata) : null];
                 values[key] = row;
@@ -16623,7 +16526,7 @@ class LdsInternalDataTable {
             },
             conflictColumns: this.conflictColumnNames,
             columns: this.columnNames,
-            rows: keys(entries).reduce((rows, key) => {
+            rows: keys$1(entries).reduce((rows, key) => {
                 const entry = entries[key];
                 const { data, metadata } = entry;
                 const row = [key, stringify(data)];
@@ -16649,7 +16552,7 @@ class LdsInternalDataTable {
                 type: 'setMetadata',
             },
             columns: [COLUMN_NAME_METADATA],
-            values: keys(entries).reduce((values, key) => {
+            values: keys$1(entries).reduce((values, key) => {
                 const { metadata } = entries[key];
                 const row = [metadata ? stringify(metadata) : null];
                 values[key] = row;
@@ -16658,7 +16561,7 @@ class LdsInternalDataTable {
         };
     }
     metadataToUpdateSQLQueries(entries, segment) {
-        return keys(entries).reduce((accu, key) => {
+        return keys$1(entries).reduce((accu, key) => {
             const { metadata } = entries[key];
             if (metadata !== undefined) {
                 accu.push({
@@ -16729,7 +16632,7 @@ class NimbusSqliteStore {
         return this.getTable(segment).getAll(segment);
     }
     setEntries(entries, segment) {
-        if (keys(entries).length === 0) {
+        if (keys$1(entries).length === 0) {
             return Promise.resolve();
         }
         const table = this.getTable(segment);
@@ -16737,7 +16640,7 @@ class NimbusSqliteStore {
         return this.batchOperationAsPromise([upsertOperation]);
     }
     setMetadata(entries, segment) {
-        if (keys(entries).length === 0) {
+        if (keys$1(entries).length === 0) {
             return Promise.resolve();
         }
         const table = this.getTable(segment);
@@ -16756,13 +16659,13 @@ class NimbusSqliteStore {
     batchOperations(operations) {
         const sqliteOperations = operations.reduce((acc, cur) => {
             if (cur.type === 'setEntries') {
-                if (keys(cur.entries).length > 0) {
+                if (keys$1(cur.entries).length > 0) {
                     const table = this.getTable(cur.segment);
                     acc.push(table.entriesToUpsertOperations(cur.entries, cur.segment));
                 }
             }
             else if (cur.type === 'setMetadata') {
-                if (keys(cur.entries).length > 0) {
+                if (keys$1(cur.entries).length > 0) {
                     const table = this.getTable(cur.segment);
                     if (this.supportsBatchUpdates) {
                         acc.push(table.metadataToUpdateOperations(cur.entries, cur.segment));
@@ -16895,7 +16798,7 @@ class AbstractKeyValueDataTable {
             },
             conflictColumns: this.conflictColumnNames,
             columns: this.columnNames,
-            rows: keys(entries).reduce((rows, key) => {
+            rows: keys$1(entries).reduce((rows, key) => {
                 const entry = entries[key];
                 rows.push([key, stringify(entry.data)]);
                 return rows;
@@ -17087,7 +16990,7 @@ function makeEnvironmentGraphqlAware(environment) {
         }
         return environment.applyCachePolicy(luvio, adapterRequestContext, buildSnapshotContext, localBuildCachedSnapshot, buildNetworkSnapshot);
     };
-    return create$1(environment, {
+    return create$2(environment, {
         rebuildSnapshot: { value: rebuildSnapshot },
         applyCachePolicy: { value: applyCachePolicy },
         setDefaultCachePolicy: { value: environment.setDefaultCachePolicy.bind(environment) },
@@ -18293,7 +18196,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$1(storeRecords).length;
+    const storeKeyLength = keys$2(storeRecords).length;
     if (storeKeyLength <= maxStoreRecords) {
         return { deallocatedCount, trimKeysSkipped: pendingTrimKeys };
     }
@@ -18369,6 +18272,78 @@ function setupObserver() {
     }
 }
 
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+
+const { keys, values, create, assign, freeze, entries } = Object;
+function isStoreKeyRecordId(key) {
+    return key.indexOf(RECORD_ID_PREFIX$1) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION$1) === -1;
+}
+function isEntryDurableRecordRepresentation(entry, key) {
+    // Either a DurableRecordRepresentation or StoreRecordError can live at a record key
+    return ((isStoreKeyRecordId(key) || isStoreKeyRecordViewEntity$1(key)) &&
+        entry.data.__type === undefined);
+}
+
+// TODO [W-15983267]: this is here for backwards compatibility from <252 and can be removed in 256
+// This HOF ensures that missing links that are stored in the "links" property in the durable store get restored to the "fields" property.
+// this code is necessary for backwards compatibility with records that were stored in the durable store before the "links" property was removed.
+function makeDurableStoreBackwardsCompatible(durableStore) {
+    const getEntries = function (entries, segment) {
+        // this HOF only inspects records in the default segment
+        if (segment !== DefaultDurableSegment) {
+            return durableStore.getEntries(entries, segment);
+        }
+        const { length: entriesLength } = entries;
+        if (entriesLength === 0) {
+            return Promise.resolve({});
+        }
+        // call base getEntries
+        return durableStore.getEntries(entries, segment).then((durableEntries) => {
+            if (durableEntries === undefined) {
+                return undefined;
+            }
+            const returnEntries = create(null);
+            const keys$1 = keys(durableEntries);
+            for (let i = 0, len = keys$1.length; i < len; i++) {
+                const key = keys$1[i];
+                const value = durableEntries[key];
+                if (value === undefined) {
+                    continue;
+                }
+                if (isEntryDurableRecordRepresentation(value, key)) {
+                    const record = value.data;
+                    const { links } = record;
+                    if (links !== undefined) {
+                        const missingLinks = keys(links);
+                        for (let j = 0, len = missingLinks.length; j < len; j++) {
+                            const fieldName = missingLinks[j];
+                            const link = links[fieldName];
+                            if (link !== undefined && link.isMissing === true) {
+                                record.fields[fieldName] = {
+                                    __state: { isMissing: true },
+                                    value: undefined,
+                                    displayValue: undefined,
+                                };
+                            }
+                        }
+                        delete record.links;
+                    }
+                }
+                returnEntries[key] = value;
+            }
+            return returnEntries;
+        });
+    };
+    return create(durableStore, {
+        getEntries: { value: getEntries, writable: true },
+    });
+}
+
 // so eslint doesn't complain about nimbus
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 /* global __nimbus */
@@ -18377,10 +18352,32 @@ let lazyDraftManager;
 let lazyLuvio;
 let lazyInternalLuvio;
 let lazyEnvironment;
-let lazyBaseDurableStore;
+let lazyDurableStore;
 let lazyNetworkAdapter;
 let lazyObjectInfoService;
 let lazyGetRecords;
+// TODO [W-123]: JHORST hoist, optimize and test this function
+const shouldFlush = (key, value) => {
+    if (!isStoreKeyRecordId$1(key)) {
+        return { flushValue: true };
+    }
+    if (value && typeof value === 'object') {
+        const fields = value.fields;
+        if (fields && typeof fields === 'object') {
+            const keys = keys$2(fields);
+            for (const key of keys) {
+                const field = fields[key];
+                if (fields && field.__state && field.__state.pending === true) {
+                    // Do not flush records if they contain pending fields but
+                    // flush the updated metadata
+                    return { flushValue: false, forceFlushMetadata: true };
+                }
+            }
+        }
+        return { flushValue: true };
+    }
+    return { flushValue: true };
+};
 /**
  * This returns the LDS on Mobile Runtime singleton object.
  */
@@ -18403,61 +18400,49 @@ function getRuntime() {
         lazyNetworkAdapter = platformNetworkAdapter(makeNetworkAdapterChunkRecordFields(NimbusNetworkAdapter, {
             reportChunkCandidateUrlLength: reportChunkCandidateUrlLength,
         }));
-        lazyBaseDurableStore = getNimbusDurableStore();
+        lazyDurableStore = makeDurableStoreBackwardsCompatible(getNimbusDurableStore());
         // specific adapters
         const internalAdapterStore = new InMemoryStore();
-        let getIngestRecordsForInternalAdapters;
-        let getIngestMetadataForInternalAdapters;
-        let getIngestStoreInternal;
-        const internalAdapterDurableStore = makeRecordDenormalizingDurableStore(lazyLuvio, lazyBaseDurableStore, () => getIngestRecordsForInternalAdapters !== undefined
-            ? getIngestRecordsForInternalAdapters()
-            : {}, () => getIngestMetadataForInternalAdapters !== undefined
-            ? getIngestMetadataForInternalAdapters()
-            : {}, () => (getIngestStoreInternal !== undefined ? getIngestStoreInternal() : undefined));
-        const { adapters: { getObjectInfo, getObjectInfos, getRecord, getObjectInfoDirectory }, durableEnvironment: internalAdapterDurableEnvironment, luvio: internalLuvio, } = buildInternalAdapters(internalAdapterStore, lazyNetworkAdapter, internalAdapterDurableStore, (apiName, objectInfo) => lazyObjectInfoService.ensureObjectInfoCached(apiName, objectInfo));
+        const { adapters: { getObjectInfo, getObjectInfos, getRecord, getObjectInfoDirectory }, luvio: internalLuvio, } = buildInternalAdapters(internalAdapterStore, lazyNetworkAdapter, lazyDurableStore, (apiName, objectInfo) => lazyObjectInfoService.ensureObjectInfoCached(apiName, objectInfo), shouldFlush);
         lazyInternalLuvio = internalLuvio;
-        getIngestRecordsForInternalAdapters =
-            internalAdapterDurableEnvironment.getIngestStagingStoreRecords;
-        getIngestMetadataForInternalAdapters =
-            internalAdapterDurableEnvironment.getIngestStagingStoreRecords;
-        getIngestStoreInternal = internalAdapterDurableEnvironment.getIngestStagingStore;
-        lazyObjectInfoService = new ObjectInfoService(getObjectInfo, getObjectInfos, getObjectInfoDirectory, lazyBaseDurableStore);
-        // creates a durable store that denormalizes scalar fields for records
-        let getIngestRecords;
-        let getIngestMetadata;
-        let getIngestStore;
-        const recordDenormingStore = makeRecordDenormalizingDurableStore(lazyLuvio, lazyBaseDurableStore, () => (getIngestRecords !== undefined ? getIngestRecords() : {}), () => (getIngestMetadata !== undefined ? getIngestMetadata() : {}), () => (getIngestStore !== undefined ? getIngestStore() : undefined), lazyBaseDurableStore);
+        lazyObjectInfoService = new ObjectInfoService(getObjectInfo, getObjectInfos, getObjectInfoDirectory, lazyDurableStore);
         const baseEnv = new Environment(store, lazyNetworkAdapter);
         const gqlEnv = makeEnvironmentGraphqlAware(baseEnv);
         const durableEnv = makeDurable(gqlEnv, {
-            durableStore: recordDenormingStore,
+            durableStore: lazyDurableStore,
             enableDurableMetadataRefresh: ldsMetadataRefreshEnabled.isOpen({ fallback: false }),
             // disable luvio deep freeze in headless environments
             disableDeepFreeze: typeof window === 'undefined',
+            shouldFlush,
         });
-        getIngestRecords = durableEnv.getIngestStagingStoreRecords;
-        getIngestMetadata = durableEnv.getIngestStagingStoreMetadata;
-        getIngestStore = durableEnv.getIngestStagingStore;
         // draft queue
-        lazyDraftQueue = buildLdsDraftQueue(recordDenormingStore);
-        const draftService = new UiApiDraftRecordService(lazyDraftQueue, () => lazyLuvio, recordDenormingStore, getObjectInfo, newRecordId, userId, formatDisplayValue);
-        const uiApiRecordHandler = new UiApiActionHandler(() => lazyLuvio, lazyNetworkAdapter, recordDenormingStore, lazyDraftQueue, getRecord, lazyObjectInfoService, isGenerated, draftService);
+        lazyDraftQueue = buildLdsDraftQueue(lazyDurableStore);
+        const draftService = new UiApiDraftRecordService(lazyDraftQueue, () => lazyLuvio, lazyDurableStore, getObjectInfo, newRecordId, userId, formatDisplayValue);
+        const uiApiRecordHandler = new UiApiActionHandler(() => lazyLuvio, lazyNetworkAdapter, lazyDurableStore, lazyDraftQueue, getRecord, lazyObjectInfoService, isGenerated, draftService);
         const quickActionHandler = new QuickActionExecutionRepresentationHandler(() => lazyLuvio, draftService, lazyDraftQueue, lazyNetworkAdapter, isGenerated);
+        const updateRecordQuickActionHandler = new UpdateRecordQuickActionExecutionRepresentationHandler(() => lazyLuvio, draftService, lazyDraftQueue, lazyNetworkAdapter, lazyDurableStore, isGenerated);
         const contentDocumentCompositeActionHandler = new ContentDocumentCompositeRepresentationActionHandler(() => lazyLuvio, draftService, lazyDraftQueue, lazyNetworkAdapter, isGenerated, NimbusBinaryStore);
         lazyDraftQueue.addHandler(uiApiRecordHandler);
         lazyDraftQueue.addHandler(quickActionHandler);
+        lazyDraftQueue.addHandler(updateRecordQuickActionHandler);
         lazyDraftQueue.addHandler(contentDocumentCompositeActionHandler);
         // draft manager
         lazyDraftManager = new DraftManager(lazyDraftQueue);
         const objectInfoCachingEnvironment = enableObjectInfoCaching(durableEnv, lazyObjectInfoService.ensureObjectInfoCached);
-        let draftEnv = makeEnvironmentDraftAware(lazyLuvio, objectInfoCachingEnvironment, recordDenormingStore, [uiApiRecordHandler, quickActionHandler, contentDocumentCompositeActionHandler], lazyDraftQueue);
+        let draftEnv = makeEnvironmentDraftAware(lazyLuvio, objectInfoCachingEnvironment, lazyDurableStore, [
+            uiApiRecordHandler,
+            quickActionHandler,
+            updateRecordQuickActionHandler,
+            contentDocumentCompositeActionHandler,
+        ], lazyDraftQueue);
         draftEnv = makeEnvironmentUiApiRecordDraftAware(lazyLuvio, {
             store,
             handler: uiApiRecordHandler,
-            durableStore: recordDenormingStore,
+            durableStore: lazyDurableStore,
             isDraftId: isGenerated,
         }, draftEnv);
         draftEnv = performQuickActionDraftEnvironment(lazyLuvio, draftEnv, quickActionHandler);
+        draftEnv = performUpdateRecordQuickActionDraftEnvironment(lazyLuvio, draftEnv, updateRecordQuickActionHandler);
         lazyEnvironment = draftEnv;
         lazyLuvio = new Luvio(lazyEnvironment, {
             instrument: instrumentLuvio,
@@ -18478,7 +18463,7 @@ function getRuntime() {
                 isDraftId: isGenerated,
                 getCanonicalId,
             };
-            setStoreEval(sqliteStoreEvalFactory(userId, lazyBaseDurableStore, lazyObjectInfoService, draftFuncs));
+            setStoreEval(sqliteStoreEvalFactory(userId, lazyDurableStore, lazyObjectInfoService, draftFuncs));
             setDraftFunctions(draftFuncs);
         });
         // on core the graphql configuration is split so we need to set configureUIAPIGraphQL both in the
@@ -18490,7 +18475,7 @@ function getRuntime() {
                 setDraftAwareGraphQLAdapter(graphqlEvalAdapter);
             }
             else {
-                const draftAwareGraphQLAdapter = draftAwareGraphQLAdapterFactory(userId, lazyObjectInfoService, lazyBaseDurableStore, lazyLuvio, isGenerated);
+                const draftAwareGraphQLAdapter = draftAwareGraphQLAdapterFactory(userId, lazyObjectInfoService, lazyDurableStore, lazyLuvio, isGenerated);
                 setDraftAwareGraphQLAdapter(
                 // return a draft aware graphql adapter here
                 draftAwareGraphQLAdapter);
@@ -18520,7 +18505,7 @@ function getRuntime() {
         draftQueue: lazyDraftQueue,
         createPrimingSession: (config) => {
             return primingSessionFactory({
-                store: lazyBaseDurableStore,
+                store: lazyDurableStore,
                 objectInfoService: lazyObjectInfoService,
                 getLuvio: () => lazyLuvio,
                 concurrency: config.concurrency,
@@ -18528,7 +18513,7 @@ function getRuntime() {
                 getRecords: lazyGetRecords,
             });
         },
-        nimbusSqliteStore: lazyBaseDurableStore,
+        nimbusSqliteStore: lazyDurableStore,
     };
 }
 
@@ -18545,4 +18530,4 @@ register({
 });
 
 export { O11Y_NAMESPACE_LDS_MOBILE, getRuntime, registerReportObserver, reportGraphqlQueryParseError };
-// version: 1.299.0-83936bf1de
+// version: 1.301.0-ecd340c2e1