@salesforce/lds-runtime-mobile 1.302.0 → 1.304.0

package/dist/main.js

@@ -20,7 +20,7 @@ import { setupInstrumentation, instrumentAdapter as instrumentAdapter$1, instrum
 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 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 { RECORD_ID_PREFIX, RECORD_FIELDS_KEY_JUNCTION, RECORD_REPRESENTATION_NAME, extractRecordIdFromStoreKey, keyBuilderQuickActionExecutionRepresentation, ingestQuickActionExecutionRepresentation, keyBuilderContentDocumentCompositeRepresentation, getResponseCacheKeysContentDocumentCompositeRepresentation, keyBuilderFromTypeContentDocumentCompositeRepresentation, ingestContentDocumentCompositeRepresentation, keyBuilderRecord, isStoreKeyRecordViewEntity, getTypeCacheKeysRecord, keyBuilderFromTypeRecordRepresentation, ingestRecord, getRecordId18, getRecordsAdapterFactory, RecordRepresentationRepresentationType, ObjectInfoRepresentationType, getRecordAdapterFactory, getObjectInfoAdapterFactory, getObjectInfosAdapterFactory, getObjectInfoDirectoryAdapterFactory, UiApiNamespace, RecordRepresentationType, RecordRepresentationTTL, RecordRepresentationVersion } from '@salesforce/lds-adapters-uiapi-mobile';
 import ldsIdempotencyWriteDisabled from '@salesforce/gate/lds.idempotencyWriteDisabled';
 import ldsBackdatingEnabled from '@salesforce/gate/lds.backdatingEnabled';
 import FIRST_DAY_OF_WEEK from '@salesforce/i18n/firstDayOfWeek';
@@ -1575,6 +1575,32 @@ function makeDurable(environment, { durableStore, instrumentation, useRevivingSt
         }, revivingStore).finally(() => {
         });
     };
+    const expirePossibleStaleRecords = async function (keys$1, config, refresh) {
+        validateNotDisposed();
+        const metadataKeys = keys$1.map(serializeStructuredKey);
+        const now = Date.now();
+        const entries = await durableStore.getMetadata(metadataKeys, DefaultDurableSegment);
+        if (entries === undefined || keys$8(entries).length === 0) {
+            return environment.expirePossibleStaleRecords(keys$1);
+        }
+        let metaDataChanged = false;
+        const metadataEntries = metadataKeys.reduce((accu, key) => {
+            const metadataEntry = entries[key];
+            if (metadataEntry.metadata !== undefined) {
+                const metadata = { ...metadataEntry.metadata, expirationTimestamp: now };
+                accu[key] = { metadata };
+                metaDataChanged = true;
+            }
+            return accu;
+        }, {});
+        if (metaDataChanged) {
+            await durableStore.setMetadata(metadataEntries, DefaultDurableSegment);
+        }
+        if (config !== undefined && refresh !== undefined) {
+            return environment.refreshPossibleStaleRecords(config, refresh);
+        }
+        return Promise.resolve();
+    };
     // set the default cache policy of the base environment
     environment.setDefaultCachePolicy({
         type: 'stale-while-revalidate',
@@ -1607,6 +1633,7 @@ function makeDurable(environment, { durableStore, instrumentation, useRevivingSt
         handleErrorResponse: { value: handleErrorResponse },
         getNotifyChangeStoreEntries: { value: getNotifyChangeStoreEntries },
         notifyStoreUpdateAvailable: { value: notifyStoreUpdateAvailable },
+        expirePossibleStaleRecords: { value: expirePossibleStaleRecords },
     });
 }
 
@@ -5655,7 +5682,7 @@ class DurableDraftQueue {
         if (status === DraftActionStatus.Error) {
             this.state = DraftQueueState.Error;
             this.processingAction = undefined;
-            this.notifyChangedListeners({
+            await this.notifyChangedListeners({
                 type: DraftQueueEventType.ActionFailed,
                 action: action,
             });
@@ -5671,7 +5698,7 @@ class DurableDraftQueue {
         if (this.state === DraftQueueState.Waiting) {
             this.state = DraftQueueState.Started;
         }
-        this.notifyChangedListeners({
+        await this.notifyChangedListeners({
             type: DraftQueueEventType.ActionUploading,
             action: { ...action, status: DraftActionStatus.Uploading },
         });
@@ -5748,6 +5775,31 @@ class DurableDraftQueue {
             await this.startQueue();
         }
     }
+    async updateDraftAction(action) {
+        // stop queue manually
+        this.stopQueueManually();
+        const actionStatus = await this.statusOfAction(action.id);
+        if (actionStatus === DraftActionStatus.Uploading) {
+            return Promise.reject('cannot update an uploading action');
+        }
+        // save the action into the draft store
+        await this.draftStore.writeAction(action);
+        // make the handler replay these drafts on the record
+        const handler = this.getHandler(action.handler);
+        const queue = await this.getQueueActions();
+        await handler.handleActionEnqueued(action, queue);
+        // start queue safely
+        return this.startQueueSafe();
+    }
+    async statusOfAction(actionId) {
+        const queue = await this.getQueueActions();
+        const actions = queue.filter((action) => action.id === actionId);
+        if (actions.length === 0) {
+            return Promise.reject('cannot update non-existent action');
+        }
+        const action = actions[0];
+        return action.status;
+    }
     replaceAction(targetActionId, sourceActionId) {
         return this.replaceOrMergeActions(targetActionId, sourceActionId, false);
     }
@@ -5778,17 +5830,21 @@ class DurableDraftQueue {
         });
         return action;
     }
-    scheduleRetryWithSpecifiedDelay(retryDelayInMs) {
+    async scheduleRetryWithSpecifiedDelay(retryDelayInMs) {
+        await this.notifyChangedListeners({
+            type: DraftQueueEventType.QueueStateChanged,
+            state: DraftQueueState.Waiting,
+        });
         this.timeoutHandler = setTimeout(() => {
             if (this.state !== DraftQueueState.Stopped) {
                 this.processNextAction();
             }
         }, retryDelayInMs);
     }
-    scheduleRetry() {
+    async scheduleRetry() {
         const newInterval = this.retryIntervalMilliseconds * 2;
         this.retryIntervalMilliseconds = Math.min(Math.max(newInterval, this.minimumRetryInterval), this.maximumRetryInterval);
-        this.scheduleRetryWithSpecifiedDelay(this.retryIntervalMilliseconds);
+        return this.scheduleRetryWithSpecifiedDelay(this.retryIntervalMilliseconds);
     }
     async getActionsForReplaceOrMerge(targetActionId, sourceActionId) {
         const actions = await this.getQueueActions();
@@ -5914,7 +5970,8 @@ class DurableDraftStore {
             const actionArray = [];
             for (let i = 0, len = keys$1.length; i < len; i++) {
                 const key = keys$1[i];
-                actionArray.push(draftStore[key]);
+                // clone draft so we don't expose the internal draft store
+                actionArray.push(clone$1(draftStore[key]));
             }
             return actionArray;
         });
@@ -6563,6 +6620,7 @@ var DraftQueueOperationType;
     DraftQueueOperationType["ItemUpdated"] = "updated";
     DraftQueueOperationType["QueueStarted"] = "started";
     DraftQueueOperationType["QueueStopped"] = "stopped";
+    DraftQueueOperationType["QueueWaiting"] = "waiting";
 })(DraftQueueOperationType || (DraftQueueOperationType = {}));
 /**
  * Converts the internal DraftAction's ResourceRequest into
@@ -6605,6 +6663,16 @@ function toQueueState(queue) {
     };
 }
 class DraftManager {
+    shouldEmitEvent(event) {
+        // Waiting events cannot be emitted prior to 252 native clients
+        // TODO [W-16102411]: we can safely remove this backwards compatible code in 256
+        if (isDraftQueueStateChangeEvent(event) &&
+            event.state === DraftQueueState.Waiting &&
+            this.listenerVersion === undefined) {
+            return false;
+        }
+        return this.draftEventsShouldBeEmitted.includes(event.type);
+    }
     constructor(draftQueue) {
         this.listeners = [];
         this.draftEventsShouldBeEmitted = [
@@ -6618,7 +6686,7 @@ class DraftManager {
         ];
         this.draftQueue = draftQueue;
         draftQueue.registerOnChangedListener((event) => {
-            if (this.draftEventsShouldBeEmitted.includes(event.type)) {
+            if (this.shouldEmitEvent(event)) {
                 return this.callListeners(event);
             }
             return Promise.resolve();
@@ -6648,6 +6716,8 @@ class DraftManager {
                 return DraftQueueOperationType.QueueStarted;
             case DraftQueueState.Stopped:
                 return DraftQueueOperationType.QueueStopped;
+            case DraftQueueState.Waiting:
+                return DraftQueueOperationType.QueueWaiting;
             default:
                 throw Error('Unsupported event type');
         }
@@ -6705,7 +6775,8 @@ class DraftManager {
      *
      * @param listener The listener closure to subscribe to changes
      */
-    registerDraftQueueChangedListener(listener) {
+    registerDraftQueueChangedListener(listener, version = undefined) {
+        this.listenerVersion = version;
         this.listeners.push(listener);
         return () => {
             this.listeners = this.listeners.filter((l) => {
@@ -6732,6 +6803,60 @@ class DraftManager {
             };
         });
     }
+    async mergePerformQuickAction(actionId, fields) {
+        if (!this.isValidFieldMap(fields)) {
+            return Promise.reject('fields is not valid');
+        }
+        const queue = await this.draftQueue.getQueueActions();
+        const actions = queue.filter((action) => action.id === actionId);
+        if (actions.length === 0) {
+            return Promise.reject('cannot edit non-existent action');
+        }
+        const action = actions[0];
+        if (!this.isPerformQuickActionDraft(action, 'post')) {
+            return Promise.reject('cannot edit incompatible action type or uploading actions');
+        }
+        action.data.body.fields = { ...action.data.body.fields, ...fields };
+        await this.draftQueue.updateDraftAction(action);
+        return this.buildDraftQueueItem(action);
+    }
+    isValidFieldMap(fields) {
+        const keys$1 = keys$6(fields);
+        const validTypes = ['string', 'number', 'null', 'boolean'];
+        for (let i = 0; i < keys$1.length; i++) {
+            const key = keys$1[i];
+            const value = fields[key];
+            if (!validTypes.includes(typeof value)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    isPerformQuickActionDraft(action, method) {
+        const data = action.data;
+        const isPerformQuickAction = data.basePath.startsWith('/ui-api/actions/perform-quick-action/');
+        const methodMatches = data.method === method;
+        const notUploading = action.status !== DraftActionStatus.Uploading;
+        return isPerformQuickAction && methodMatches && notUploading;
+    }
+    async mergePerformUpdateRecordQuickAction(actionId, fields) {
+        if (!this.isValidFieldMap(fields)) {
+            return Promise.reject('fields is not valid');
+        }
+        const queue = await this.draftQueue.getQueueActions();
+        const actions = queue.filter((action) => action.id === actionId);
+        if (actions.length === 0) {
+            return Promise.reject('cannot edit non-existent action');
+        }
+        const action = actions[0];
+        if (!this.isPerformQuickActionDraft(action, 'patch')) {
+            return Promise.reject('cannot edit incompatible action type or uploading actions');
+        }
+        const data = action.data;
+        data.body.fields = { ...data.body.fields, ...fields };
+        await this.draftQueue.updateDraftAction(action);
+        return this.buildDraftQueueItem(action);
+    }
     buildDraftQueueItem(action) {
         const operationType = getOperationTypeFrom(action);
         const { id, status, timestamp, targetId, metadata } = action;
@@ -7039,6 +7164,12 @@ function getDenormalizedRecord(recordKey, durableStore) {
 function isStoreRecordError(storeRecord) {
     return storeRecord.__type === 'error';
 }
+function isDraftFieldPending(field) {
+    return !!(field.__state && field.__state.pending === true);
+}
+function isDraftFieldMissing(field) {
+    return !!(field.__state && field.__state.isMissing === true);
+}
 
 /**
  * Checks if a resource request is a GET method on the record endpoint
@@ -7730,12 +7861,9 @@ function applyReferenceLinksToDraft(record, draftMetadata) {
         }
         const { dataType, relationshipName, referenceToInfos } = fieldInfo;
         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;
+        if (isDraftFieldPending(draftFieldNode) || isDraftFieldMissing(draftFieldNode)) {
+            continue;
         }
         const draftFieldValue = draftFieldNode.value;
         if (dataType === 'Reference' && relationshipName !== null) {
@@ -8530,6 +8658,7 @@ class QuickActionExecutionRepresentationHandler extends AbstractResourceRequestA
             isCreated: true,
             isSuccess: true,
             successMessage: `record created.`,
+            drafts: { draftActionId: action.id },
         });
     }
     getDraftMetadata(_key) {
@@ -8647,6 +8776,7 @@ class UpdateRecordQuickActionExecutionRepresentationHandler extends AbstractReso
             isCreated: false,
             isSuccess: true,
             successMessage: `record updated.`,
+            drafts: { draftActionId: action.id },
         });
     }
     async getDraftMetadata(key) {
@@ -8724,7 +8854,29 @@ function isCreateContentDocumentAndVersionDraftAdapterEvent(customEvent) {
     return customEvent.namespace === CONTENT_DOCUMENT_AND_VERSION_NAMESPACE;
 }
 
+// so eslint doesn't complain about nimbus
+/* global __nimbus */
 const ContentDocumentCompositeKeyPrefix = 'UiApi::ContentDocumentCompositeRepresentation:';
+function chunkToBase64(chunk) {
+    let binary = '';
+    const chunkSize = 32 * 1024;
+    for (let i = 0; i < chunk.length; i += chunkSize) {
+        binary += String.fromCharCode.apply(null, chunk.subarray(i, i + chunkSize));
+    }
+    return btoa(binary);
+}
+async function streamBufferToBinaryStore(binaryStore, buffer, mimeType) {
+    const uri = await binaryStore.createStream(mimeType);
+    const bufferSize = 64 * 1024; // 64k buffer size
+    const uint8Array = new Uint8Array(buffer);
+    for (let offset = 0; offset < uint8Array.length; offset += bufferSize) {
+        const chunk = uint8Array.subarray(offset, Math.min(offset + bufferSize, uint8Array.length));
+        const base64Chunk = chunkToBase64(chunk);
+        await binaryStore.writeToStream(uri, base64Chunk);
+    }
+    await binaryStore.closeStream(uri);
+    return uri;
+}
 function createContentDocumentAndVersionDraftAdapterFactory(luvio, binaryStore, actionHandler) {
     const overriddenLuvio = buildLuvioOverrideForDraftAdapters(luvio, actionHandler, (key) => {
         // if the key is for our top-level response shape
@@ -8747,7 +8899,14 @@ function createContentDocumentAndVersionDraftAdapterFactory(luvio, binaryStore,
             const { fileData } = config;
             const { name, size, type } = fileData;
             const buffer = await fileData.arrayBuffer();
-            const uri = await binaryStore.store(new Uint8Array(buffer), type, size);
+            var uri;
+            // see if new chunking-api exists, if it doesnt fall back to memory-intensive mobile api
+            if (!__nimbus.plugins.LdsBinaryStorePlugin.createStream) {
+                uri = await binaryStore.store(new Uint8Array(buffer), type, size);
+            }
+            else {
+                uri = await streamBufferToBinaryStore(binaryStore, buffer, type);
+            }
             config.fileData = {
                 isFileReference: true,
                 handle: uri,
@@ -9586,7 +9745,7 @@ function recordLoaderFactory(query) {
     return new DataLoader(batchRecordQuery);
 }
 
-function createContext(store, objectInfos, eventEmitter, settings, snapshot, draftFunctions) {
+function createContext(store, objectInfos, eventEmitter, settings, snapshot, mappedCursors = new Map(), draftFunctions) {
     store.query.bind(store);
     const query = (sql, params) => {
         const now = Date.now();
@@ -9613,7 +9772,9 @@ function createContext(store, objectInfos, eventEmitter, settings, snapshot, dra
         Record,
         snapshot,
         seenRecordIds: new Set(),
+        possibleStaleRecordMap: new Map(),
         draftFunctions,
+        mappedCursors,
     };
 }
 
@@ -10224,7 +10385,6 @@ function isTodayStartOfWeek() {
 
 const JSON_EXTRACT_PATH_INGESTION_TIMESTAMP = '$.ingestionTimestamp';
 const JSON_EXTRACT_PATH_INGESTION_APINAME = '$.apiName';
-const JSON_EXTRACT_PATH_DRAFTS = '$.drafts';
 
 const MultiPickListValueSeparator = ';';
 function filterToPredicates(where, recordType, alias, objectInfoMap, joins, draftFunctions) {
@@ -10765,14 +10925,10 @@ function buildQuery(config) {
     const predicates = buildPredicates(config);
     const orderBy = buildOrderBy(config);
     const sql = `
-        SELECT "${config.alias}".data
+        SELECT "${config.alias}".data, "${config.alias}".metadata
         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}'
-          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 ?
@@ -10784,7 +10940,6 @@ function buildQuery(config) {
     const bindings = [
         // bindings from predicates on joins
         ...joins.bindings,
-        config.ingestionTimestamp,
         // where clause and parent scope bindings
         ...predicates.bindings,
         // limit binding
@@ -10811,29 +10966,19 @@ function buildJoins(config) {
     if (allJoins.length === 0)
         return { sql, bindings };
     sql = allJoins.reduce((joinAccumulator, join) => {
-        let timestampAdded = false;
         const joinConditions = join.conditions.reduce((conditionAccumulator, condition) => {
             let joined_sql;
-            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}`;
+                joined_sql = ` AND ${sql}`;
                 bindings.push(...binding);
-                if (timestampAdded === false) {
-                    bindings.push(config.ingestionTimestamp);
-                    timestampAdded = true;
-                }
             }
             else {
                 // predicate on a path
                 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 (timestampAdded === false) {
-                    bindings.push(config.ingestionTimestamp);
-                    timestampAdded = true;
-                }
+                joined_sql = `${left} = ${right}`;
             }
             conditionAccumulator += joined_sql;
             return conditionAccumulator;
@@ -11502,11 +11647,15 @@ 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 isObjectDefinitionNode(node) {
+    const { kind } = node;
+    return typeof kind === 'string' && kind === 'OperationDefinition';
+}
+function operationNodeAncestor(ancestors) {
+    let operationNode = ancestors.find((a) => {
+        return !(a instanceof Array) && isObjectDefinitionNode(a);
+    });
+    return operationNode;
 }
 
 function findSpanningField(name) {
@@ -11707,44 +11856,87 @@ function atobPolyfill(data) {
 const base64encode = typeof btoa === 'function' ? btoa : btoaPolyfill;
 const base64decode = typeof atob === 'function' ? atob : atobPolyfill;
 
+// this truthy value is used to indicate a premature end of results
+const EARLY_END = 1;
 function cursorResolver(source) {
-    return encodeV1Cursor(source.index);
+    let cursor = {
+        i: source.index,
+    };
+    if (source.earlyEnd) {
+        cursor.e = EARLY_END;
+    }
+    return encodeV1Cursor(cursor);
 }
 function pageInfoResolver(source) {
     if (source.records.length === 0) {
+        // we may have found no records, but if more exist we need to
+        // return a valid cursor that can be passed as the next `after`
+        if (source.earlyEnd) {
+            return {
+                startCursor: null,
+                endCursor: encodeV1Cursor({
+                    i: source.offset,
+                    e: EARLY_END,
+                }),
+                hasNextPage: source.hasNextPage,
+            };
+        }
         return {
             startCursor: null,
             endCursor: null,
-            hasNextPage: false,
+            hasNextPage: source.hasNextPage,
         };
     }
     let startIndex = source.records[0].index;
+    let startCursor = {
+        i: startIndex,
+    };
     let endIndex = source.records[source.records.length - 1].index;
+    let endCursor = {
+        i: endIndex,
+    };
+    if (source.earlyEnd) {
+        startCursor.e = EARLY_END;
+        endCursor.e = EARLY_END;
+    }
     return {
-        startCursor: encodeV1Cursor(startIndex),
-        endCursor: encodeV1Cursor(endIndex),
+        startCursor: encodeV1Cursor(startCursor),
+        endCursor: encodeV1Cursor(endCursor),
         hasNextPage: source.hasNextPage,
     };
 }
 function pageResultCountResolver(source) {
     return source.records.length;
 }
-function encodeV1Cursor(index) {
-    return base64encode(`v1:${index}`);
+function isLocalCursor(maybeCursor) {
+    return (!!maybeCursor &&
+        typeof maybeCursor === 'object' &&
+        'i' in maybeCursor &&
+        typeof maybeCursor.i === 'number');
+}
+function encodeV1Cursor(cursor) {
+    return base64encode(stringify$3(cursor));
 }
-const cursorRegex = /^v1:(?<index>\d+)$/;
+const CURSOR_PARSE_ERROR = 'Unable to parse cursor';
 function decodeV1Cursor(base64cursor) {
-    const cursor = base64decode(base64cursor);
-    if (!cursor) {
+    let maybeCursor;
+    try {
+        const cursorString = base64decode(base64cursor);
+        maybeCursor = parse$3(cursorString);
+    }
+    catch (error) {
+        let message = CURSOR_PARSE_ERROR;
+        if (error instanceof Error) {
+            message += ': ' + error.message;
+        }
         // eslint-disable-next-line @salesforce/lds/no-error-in-production
-        throw new Error('Unable to parse cursor');
+        throw new Error(message);
     }
-    const found = cursor.match(cursorRegex);
-    if (!found || !found.groups) {
+    if (!isLocalCursor(maybeCursor)) {
         // eslint-disable-next-line @salesforce/lds/no-error-in-production
-        throw new Error('Unable to parse cursor');
+        throw new Error(CURSOR_PARSE_ERROR);
     }
-    return Number(found.groups.index);
+    return maybeCursor;
 }
 /**
  * Check the selections for any selection matching `pageInfo { hasNextPage }`
@@ -11782,6 +11974,164 @@ function selectionIncludesHasNextPage(selections, fragments) {
     return false;
 }
 
+const END_CURSOR = '__END__';
+// find the closest matching cursor in the server pagination metadata
+function mapCursorValue(originalValue, paginationMetadata) {
+    let mappedValue = null;
+    if (!originalValue) {
+        return mappedValue;
+    }
+    // flip the pagination metadata into an array by index.
+    let cursors = [];
+    for (const [cursor, index] of Object.entries(paginationMetadata)) {
+        if (index === undefined)
+            continue;
+        cursors[index] = cursor;
+    }
+    let cursor = decodeV1Cursor(originalValue);
+    // cursors containe 1-based indexes, adjust back to 0-based
+    let index = cursor.i - 1;
+    if (
+    // cursor.e being truthy means we had premature end of results and
+    // should pin to the last known server cursor
+    !cursor.e &&
+        // check that the index we have is within the bounds of known cursors
+        index >= 0 &&
+        index < cursors.length &&
+        // and make sure the cursor is not the server end marker
+        cursors[index] !== END_CURSOR) {
+        mappedValue = cursors[index];
+    }
+    else {
+        // in this case, either our local cursor is beyond the max server cursor, or
+        // the local cursor precedes the max server cursor and we ran out of locally
+        // cached results. either way, find the last known server cursor and map to that.
+        for (let i = cursors.length; i > 0; --i) {
+            let cursor = cursors[i - 1];
+            if (cursor !== END_CURSOR) {
+                mappedValue = cursor;
+                break;
+            }
+        }
+    }
+    return mappedValue;
+}
+// map all pagination cursors in the document
+async function mapPaginationCursors(originalAST, variables, store) {
+    // first pass, identify record query cache keys for reading pagination metadata
+    let requiredPaginationMetadataKeys = [];
+    visit(originalAST, {
+        Field(node, _key, _parent, _path, ancestors) {
+            // is it a record query?
+            if (!isRecordQuery(node)) {
+                return;
+            }
+            // does it have a defined `after` argument?
+            let after = node.arguments &&
+                node.arguments.find((a) => {
+                    return a.name.value === 'after';
+                });
+            if (after && (after.value.kind === 'StringValue' || after.value.kind === 'Variable')) {
+                let operationNode = operationNodeAncestor(ancestors);
+                if (!operationNode) {
+                    return false;
+                }
+                let key = buildKeyStringForRecordQuery(operationNode, variables, node.arguments || [], node.name.value);
+                requiredPaginationMetadataKeys.push(key);
+            }
+            // don't need to descend into this node
+            return false;
+        },
+    });
+    // read pagination metadata for identified record queries
+    let paginationMetadataMap = await readPaginationMetadataForKeys(requiredPaginationMetadataKeys, store.query.bind(store));
+    // holds the original cursor values that were mapped back to server cursors
+    let mappedCursors = new Map();
+    // rewrite nodes/variables with mapped cursors now that we read the pagination metadata
+    let ast = visit(originalAST, {
+        Field(node, _key, _parent, _path, ancestors) {
+            // is it a record query?
+            if (!isRecordQuery(node)) {
+                // not returning false, we might be in the parent of a record query
+                return;
+            }
+            // does it have a defined `after` argument?
+            if (!node.arguments)
+                return false;
+            let after = node.arguments.find((a) => {
+                return a.name.value === 'after';
+            });
+            if (!after)
+                return false;
+            if (after.value.kind === 'StringValue' || after.value.kind === 'Variable') {
+                let operationNode = operationNodeAncestor(ancestors);
+                if (!operationNode) {
+                    return false;
+                }
+                let key = buildKeyStringForRecordQuery(operationNode, variables, node.arguments || [], node.name.value);
+                // pagination metadata may be missing, e.g. due to being offline
+                let paginationMetadata = paginationMetadataMap.get(key) || {};
+                if (after.value.kind === 'StringValue') {
+                    let originalValue = after.value.value;
+                    mappedCursors.set(key, originalValue);
+                    let mappedValue = mapCursorValue(originalValue, paginationMetadata);
+                    if (!mappedValue) {
+                        // there were no results from the server, remove after argument
+                        return {
+                            ...node,
+                            arguments: node.arguments.filter((a) => a !== after),
+                        };
+                    }
+                    // return a new replacement node
+                    return {
+                        ...node,
+                        arguments: node.arguments.map((a) => {
+                            if (a !== after)
+                                return a;
+                            return {
+                                ...a,
+                                value: {
+                                    kind: 'StringValue',
+                                    value: mappedValue,
+                                },
+                            };
+                        }),
+                    };
+                }
+                else if (after.value.kind === 'Variable') {
+                    // rewrite the variable
+                    let variableName = after.value.name.value;
+                    let variableValue = variables[variableName];
+                    mappedCursors.set(key, variableValue);
+                    let mappedValue = mapCursorValue(variableValue, paginationMetadata);
+                    variables[variableName] = mappedValue;
+                }
+                // don't need to descend into this node
+                return false;
+            }
+        },
+    });
+    return {
+        ast,
+        mappedCursors,
+    };
+}
+async function readPaginationMetadataForKeys(keys, query) {
+    let metadataMap = new Map();
+    if (keys.length === 0)
+        return metadataMap;
+    const sql = `SELECT key, data FROM lds_data WHERE key in (${Array(keys.length)
+        .fill('?')
+        .join(',')})`;
+    const results = await query(sql, keys.map((k) => k + '__pagination'));
+    for (let row of results.rows) {
+        let key = row[0].replace(/__pagination$/, '');
+        let metadata = parse$3(row[1]);
+        metadataMap.set(key, metadata);
+    }
+    return metadataMap;
+}
+
 /*
 resolves connections...
 */
@@ -11803,8 +12153,14 @@ async function connectionResolver(obj, args, context, info) {
         const childRelationship = parentObjectInfo &&
             parentObjectInfo.childRelationships.find((rel) => rel.relationshipName === info.fieldName);
         // or emit/throw if we want to report it
-        if (!childRelationship)
-            return { records: [], hasNextPage: false };
+        if (!childRelationship) {
+            return {
+                records: [],
+                hasNextPage: false,
+                earlyEnd: false,
+                offset: 0,
+            };
+        }
         alias = childRelationship.childObjectApiName;
         childRelationshipFieldName = childRelationship.fieldName;
     }
@@ -11823,7 +12179,12 @@ async function connectionResolver(obj, args, context, info) {
     }
     let offset = 0;
     if (args.after) {
-        offset = decodeV1Cursor(args.after) + 1;
+        let originalCursor = context.mappedCursors.get(queryCacheKey);
+        if (!originalCursor) {
+            // eslint-disable-next-line @salesforce/lds/no-error-in-production
+            throw new Error('Internal Error: unable to determine `after` cursor value');
+        }
+        offset = decodeV1Cursor(originalCursor).i;
     }
     // if the query wants to know `hasNextPage` then we need to request 1 additional record
     let selections = info.fieldNodes
@@ -11832,7 +12193,7 @@ async function connectionResolver(obj, args, context, info) {
     let wantsHasNextPage = selectionIncludesHasNextPage(selections, info.fragments);
     let paginationMetadata = undefined;
     if (wantsHasNextPage) {
-        paginationMetadata = await readPaginationMetadataForKey(queryCacheKey, query);
+        paginationMetadata = await readPaginationMetadataForKeys([queryCacheKey], query);
     }
     let internalLimit = limit + (wantsHasNextPage ? 1 : 0);
     // Alias starts as entity's ApiName
@@ -11843,36 +12204,60 @@ async function connectionResolver(obj, args, context, info) {
         orderBy: orderByToPredicate(args.orderBy, alias, alias, context.objectInfos),
         limit: internalLimit,
         offset,
-        ingestionTimestamp,
     };
     const { sql, bindings } = buildQuery(queryConfig);
     const results = await query(sql, bindings);
     let hasNextPage = false;
+    let earlyEnd = 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) {
+        else if (!paginationMetadata ||
+            !paginationMetadata.has(queryCacheKey) ||
+            paginationMetadata.get(queryCacheKey).__END__ === undefined) {
             // more records may exist on the server
             hasNextPage = true;
+            // we hit the end of our local records, so we need to know that we
+            // should start at the end of known server cursors
+            if (results.rows.length < limit) {
+                earlyEnd = true;
+            }
         }
     }
     //map each sql result with the ingestion timestamp to pass it down a level
-    let records = results.rows
-        .map((row) => parse$3(row[0]))
-        .map((recordRepresentation, index) => {
+    let records = results.rows.map((row, index) => {
+        const recordMetadataResult = {
+            recordRepresentation: parse$3(row[0]),
+            metadata: parse$3(row[1]),
+        };
+        const { recordRepresentation, metadata } = recordMetadataResult;
         context.seenRecordIds.add(recordRepresentation.id);
+        if (metadata.ingestionTimestamp < ingestionTimestamp &&
+            recordRepresentation.drafts === undefined) {
+            if (context.possibleStaleRecordMap.has(recordRepresentation.apiName) === false) {
+                context.possibleStaleRecordMap.set(recordRepresentation.apiName, []);
+            }
+            const ids = context.possibleStaleRecordMap.get(recordRepresentation.apiName);
+            if (ids !== undefined) {
+                ids.push(recordRepresentation.id);
+                context.possibleStaleRecordMap.set(recordRepresentation.apiName, ids);
+            }
+        }
         return {
             recordRepresentation,
             ingestionTimestamp,
-            index: index + offset,
+            index: index + offset + 1,
+            earlyEnd,
         };
     });
     return {
         records,
         hasNextPage,
+        earlyEnd,
+        offset,
     };
 }
 /**
@@ -12670,7 +13055,7 @@ function getTextAreaType(field) {
     return 'TextAreaValue';
 }
 
-async function evaluate(config, observers, settings, objectInfos, store, snapshot, cache, draftFunctions) {
+async function evaluate(config, observers, settings, objectInfos, store, snapshot, cache, draftFunctions, mappedCursors) {
     const eventEmitter = createCustomAdapterEventEmitter(GRAPHQL_EVAL_NAMESPACE, observers);
     // this is only wrapped in a try to execute the event after the result was returned
     try {
@@ -12729,7 +13114,7 @@ async function evaluate(config, observers, settings, objectInfos, store, snapsho
         eventEmitter({ type: 'graphql-preconditions-met' });
         // create the resolver request context, runtime values and functions for
         // resolvers to do their job.
-        const contextValue = createContext(store, objectInfos, eventEmitter, settings, snapshot, draftFunctions);
+        const contextValue = createContext(store, objectInfos, eventEmitter, settings, snapshot, mappedCursors, draftFunctions);
         // We're building this from scratch from each request.  If this becomes a
         // hotspot we can pull it up and memoize it later
         const schema = createSchemaWithCache(objectInfos, cache);
@@ -12754,7 +13139,11 @@ async function evaluate(config, observers, settings, objectInfos, store, snapsho
                 seenRecordIds.push(queryString);
             });
         }
-        return { result, seenRecordIds };
+        return {
+            result,
+            seenRecordIds,
+            possibleStaleRecordMap: contextValue.possibleStaleRecordMap,
+        };
     }
     finally {
         eventEmitter({ type: 'graphql-eval-end' });
@@ -14478,7 +14867,11 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
     return async function draftAwareGraphQLAdapter(config, buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy, requestContext = {}) {
         //create a copy to not accidentally modify the AST in the astResolver map of luvio
         const copy = parse$3(stringify$3(config.query));
+        // the injected ast has extra fields needed for eval in it
         let injectedAST;
+        // the cursor mapped ast is passed upstream so it won't reject on our local cursors
+        let cursorMappedAST;
+        let mappedCursors = new Map();
         let objectInfoNeeded = {};
         let unmappedDraftIDs;
         let internalRequestContext = {
@@ -14494,6 +14887,7 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
                 objectInfos: objectInfoNeeded,
                 unmappedDraftIDs,
             } = await injectSyntheticFields(copy, objectInfoService, draftFunctions, config.variables));
+            ({ ast: cursorMappedAST, mappedCursors } = await mapPaginationCursors(injectedAST, config.variables || {}, store));
             if (config.variables) {
                 config.variables = replaceDraftIdsInVariables(config.variables, draftFunctions, unmappedDraftIDs);
             }
@@ -14525,7 +14919,7 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
         const nonEvaluatedSnapshot = (await luvio.applyCachePolicy(internalRequestContext, {
             config: {
                 ...config,
-                query: injectedAST,
+                query: cursorMappedAST,
             },
             luvio,
             gqlEval: true,
@@ -14538,12 +14932,17 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
             : [];
         let gqlResult;
         let seenRecordIds;
+        let possibleStaleRecordMap;
         try {
-            ({ result: gqlResult, seenRecordIds } = await evaluate({
+            ({
+                result: gqlResult,
+                seenRecordIds,
+                possibleStaleRecordMap,
+            } = await evaluate({
                 ...config,
                 //need to create another copy of the ast for future writes
                 query: parse$3(stringify$3(injectedAST)),
-            }, observers, { userId }, objectInfoNeeded, store, nonEvaluatedSnapshot, graphqlSchemaCache));
+            }, observers, { userId }, objectInfoNeeded, store, nonEvaluatedSnapshot, graphqlSchemaCache, draftFunctions, mappedCursors));
         }
         catch (throwable) {
             const error = throwable;
@@ -14569,13 +14968,18 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
         const seenRecords = createSeenRecords(seenRecordIds, nonEvaluatedSnapshot);
         const recordId = generateUniqueRecordId();
         const rebuildWithLocalEval = async (originalSnapshot) => {
-            let { result: rebuildResult, seenRecordIds } = await evaluate({
+            let { result: rebuildResult, seenRecordIds, possibleStaleRecordMap, } = await evaluate({
                 ...config,
                 query: injectedAST,
-            }, observers, { userId }, objectInfoNeeded, store, originalSnapshot, graphqlSchemaCache, draftFunctions);
+            }, observers, { userId }, objectInfoNeeded, store, originalSnapshot, graphqlSchemaCache, draftFunctions, mappedCursors);
             if (!rebuildResult.errors) {
                 rebuildResult = removeSyntheticFields(rebuildResult, config.query);
             }
+            let snapshotState = 'Fulfilled';
+            if (possibleStaleRecordMap.size > 0) {
+                initiateStaleRecordRefresh(luvio, possibleStaleRecordMap);
+                snapshotState = 'Stale';
+            }
             if (objectsDeepEqual(rebuildResult, originalSnapshot.data)) {
                 return originalSnapshot;
             }
@@ -14584,6 +14988,7 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
                 ...originalSnapshot,
                 data: rebuildResult,
                 recordId,
+                state: snapshotState,
                 seenRecords: createSeenRecords(seenRecordIds, nonEvaluatedSnapshot),
                 rebuildWithLocalEval,
             };
@@ -14621,9 +15026,31 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
                 },
             };
         }
+        if (possibleStaleRecordMap.size > 0) {
+            initiateStaleRecordRefresh(luvio, possibleStaleRecordMap);
+            resultSnapshot.state = 'Stale';
+        }
         return resultSnapshot;
     };
 }
+function initiateStaleRecordRefresh(luvio, keyMap) {
+    const staleRecordKeys = from$1(keyMap.values())
+        .flat()
+        .map((id) => `UiApi::RecordRepresentation:${id}`);
+    luvio.storeExpirePossibleStaleRecords(staleRecordKeys, makeGetRecordsConfig(keyMap), getRecordsAdapterFactory(luvio));
+}
+function makeGetRecordsConfig(keyMap) {
+    const records = [];
+    keyMap.forEach((recordIds, apiName) => {
+        records.push({
+            recordIds,
+            fields: [`${apiName}.Id`],
+        });
+    });
+    return {
+        records,
+    };
+}
 
 function environmentAwareGraphQLBatchAdapterFactory(objectInfoService, luvio, isDraftId) {
     return async function environmentAwareGraphQLBatchAdapter(config, buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy, requestContext = {}) {
@@ -15770,6 +16197,9 @@ class NimbusDraftQueue {
     removeHandler(_id) {
         return Promise.reject(new Error('Cannot call setMetadata from the NimbusDraftQueue'));
     }
+    updateDraftAction(_action) {
+        return Promise.reject(new Error('Cannot call updateDraftAction from the NimbusDraftQueue'));
+    }
 }
 
 function attachObserversToAdapterRequestContext(observers, adapterRequestContext) {
@@ -17027,6 +17457,21 @@ const NimbusBinaryStore = {
             __nimbus.plugins.LdsBinaryStorePlugin.setCanonicalUrl(uri, canonicalUrl, ttlSeconds, resolve, (err) => reject(errorMessageToError(err)));
         });
     },
+    createStream: function (type) {
+        return new Promise((resolve, reject) => {
+            __nimbus.plugins.LdsBinaryStorePlugin.createStream(type, resolve, (err) => reject(errorMessageToError(err)));
+        });
+    },
+    writeToStream: function (uri, chunk) {
+        return new Promise((resolve, reject) => {
+            __nimbus.plugins.LdsBinaryStorePlugin.writeToStream(uri, chunk, resolve, (err) => reject(errorMessageToError(err)));
+        });
+    },
+    closeStream: function (uri) {
+        return new Promise((resolve, reject) => {
+            __nimbus.plugins.LdsBinaryStorePlugin.closeStream(uri, resolve, (err) => reject(errorMessageToError(err)));
+        });
+    },
 };
 
 /**
@@ -18356,7 +18801,6 @@ 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 };
@@ -18530,4 +18974,4 @@ register({
 });
 
 export { O11Y_NAMESPACE_LDS_MOBILE, getRuntime, registerReportObserver, reportGraphqlQueryParseError };
-// version: 1.302.0-e45992a1f4
+// version: 1.304.0-aa3e5f9550