@salesforce/lds-worker-api 1.110.1 → 1.111.0

package/dist/standalone/es/lds-worker-api.js

@@ -3649,7 +3649,7 @@ class Luvio {
         return this.environment.buildStructuredKey(namespace, representationName, idValues);
     }
 }
-// engine version: 0.135.4-ca0c061d
+// engine version: 0.136.5-77eb3bb4
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -3776,7 +3776,7 @@ function withDefaultLuvio(callback) {
     }
     callbacks.push(callback);
 }
-// version: 1.110.1-cc1242727
+// version: 1.111.0-f30e5e921
 
 // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
 function instrumentAdapter$1(createFunction, _metadata) {
@@ -15200,7 +15200,7 @@ function parseAndVisit(source) {
     updateReferenceMapWithKnownKey(ast, luvioDocumentNode);
     return luvioDocumentNode;
 }
-// version: 1.110.1-cc1242727
+// version: 1.111.0-f30e5e921
 
 function unwrap(data) {
     // The lwc-luvio bindings import a function from lwc called "unwrap".
@@ -16081,7 +16081,7 @@ function createGraphQLWireAdapterConstructor(luvio, adapter, metadata, astResolv
     const { apiFamily, name } = metadata;
     return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
 }
-// version: 1.110.1-cc1242727
+// version: 1.111.0-f30e5e921
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -16164,7 +16164,7 @@ var FragmentReadResultState;
 ({
     state: FragmentReadResultState.Missing,
 });
-// engine version: 0.135.4-ca0c061d
+// engine version: 0.136.5-77eb3bb4
 
 const { keys: ObjectKeys$3, freeze: ObjectFreeze$3, create: ObjectCreate$3 } = Object;
 
@@ -20818,7 +20818,7 @@ function tokenFromOffset$1(paginationMetadata, offset) {
         }
     }
 }
-function tokenForAtMost(paginationMetadata, maxOffset) {
+function tokenForAtMost$1(paginationMetadata, maxOffset) {
     const tokens = Object.keys(paginationMetadata);
     let tokenResult = undefined;
     let offsetResult = -1;
@@ -22624,7 +22624,7 @@ function minimizePaginationParams$1(luvio, resourceParams, cacheSnapshot) {
                 return [undefined, -1];
             }
             const maxOffset = configTokenOffset + num;
-            const [token, offset] = tokenForAtMost(paginationMetadata, maxOffset);
+            const [token, offset] = tokenForAtMost$1(paginationMetadata, maxOffset);
             if (token !== undefined) {
                 return [token, configPageSize - (offset - configTokenOffset)];
             }
@@ -23045,7 +23045,7 @@ function prepareRequest_getMruListRecords(luvio, config, listInfo, snapshot) {
             pageToken: config.pageToken,
             pagination: {
                 offsetFromToken: offsetFromToken$1,
-                tokenForAtMost,
+                tokenForAtMost: tokenForAtMost$1,
                 paginationMetadata,
             },
         });
@@ -23400,7 +23400,7 @@ function prepareRequest_getListRecords(luvio, context, config, listInfo, snapsho
             pageToken: config.pageToken,
             pagination: {
                 offsetFromToken: offsetFromToken$1,
-                tokenForAtMost,
+                tokenForAtMost: tokenForAtMost$1,
                 paginationMetadata,
             },
         });
@@ -40367,7 +40367,7 @@ function minimizePaginationParams(luvio, resourceParams, cacheSnapshot) {
                 return [undefined, -1];
             }
             const maxOffset = configTokenOffset + num;
-            const [token, offset] = tokenForAtMost(paginationMetadata, maxOffset);
+            const [token, offset] = tokenForAtMost$1(paginationMetadata, maxOffset);
             if (token !== undefined) {
                 return [token, configPageSize - (offset - configTokenOffset)];
             }
@@ -41964,11 +41964,11 @@ const buildNetworkSnapshot$6 = (luvio, context, config, options) => {
                 trackedFields: optionalFieldsTrie,
                 serverRequestCount: 1,
             }), body);
+            const snapshot = buildCachedSnapshot$1(luvio, context, {
+                ...config,
+                recordTypeId: responseRecordTypeId,
+            });
             return luvio.storeBroadcast().then(() => {
-                const snapshot = buildCachedSnapshot$1(luvio, context, {
-                    ...config,
-                    recordTypeId: responseRecordTypeId,
-                });
                 return snapshot;
             });
         }, () => {
@@ -44024,7 +44024,7 @@ withDefaultLuvio((luvio) => {
         dropFunction: instrumentation$2.notifyRecordUpdateAvailableDropped,
     });
 });
-// version: 1.110.1-cc1242727
+// version: 1.111.0-f30e5e921
 
 var caseSensitiveUserId = '005B0000000GR4OIAW';
 
@@ -45107,10 +45107,10 @@ function makeDurable(environment, { durableStore, instrumentation }) {
     };
     const storeBroadcast = function (_rebuildSnapshot, _snapshotDataAvailable) {
         validateNotDisposed();
-        // return resolved promise here and wait for the L2 flush to happen in handleSuccessResponse,
-        // that flush will cause the onChanged handler to fire which will revive
-        // records to the main L1 store and call the base storeBroadcast
-        return Promise.resolve();
+        // publishing to L2 is essentially "broadcasting" because the onChanged
+        // handler will fire which will revive records to the main L1 store and
+        // call the base storeBroadcast
+        return publishChangesToDurableStore();
     };
     const publishChangesToDurableStore = function () {
         validateNotDisposed();
@@ -45331,7 +45331,6 @@ function makeDurable(environment, { durableStore, instrumentation }) {
                 // we don't need to prime metadata
                 () => { });
                 snapshotFromMemoryIngest = await ingestAndBroadcastFunc();
-                await publishChangesToDurableStore();
             })();
             for (const key of keysToReviveAsArray) {
                 // we are overwriting the previous promise at this key, but that
@@ -45359,7 +45358,6 @@ function makeDurable(environment, { durableStore, instrumentation }) {
             // so all we have to do is ingest then write to L2
             ingestStagingStore = buildIngestStagingStore(environment);
             snapshotFromMemoryIngest = await ingestAndBroadcastFunc();
-            await publishChangesToDurableStore();
         }
         if (snapshotFromMemoryIngest === undefined) {
             return undefined;
@@ -45372,12 +45370,10 @@ function makeDurable(environment, { durableStore, instrumentation }) {
         const result = await reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, () => environment.storeLookup(select, environment.createSnapshot, refresh));
         return result.snapshot;
     };
-    const handleErrorResponse = function (ingestAndBroadcastFunc) {
+    const handleErrorResponse = async function (ingestAndBroadcastFunc) {
         validateNotDisposed();
-        const snapshotFromMemoryIngest = ingestAndBroadcastFunc();
-        return publishChangesToDurableStore().then(() => {
-            return snapshotFromMemoryIngest;
-        });
+        ingestStagingStore = buildIngestStagingStore(environment);
+        return ingestAndBroadcastFunc();
     };
     const getNotifyChangeStoreEntries = function (keys) {
         validateNotDisposed();
@@ -48402,6 +48398,58 @@ function makeStoreEval(preconditioner, objectInfoService, userId, contextProvide
  * For full license text, see the LICENSE.txt file
  */
 
+/* Ideally we would use AbortController but it does not exist in V8, if it is ever polyfilled we can swap for it */
+class LdsAbortController {
+    constructor() {
+        this.signal = new AbortSignal();
+    }
+    abort() {
+        this.signal.abort();
+    }
+}
+class AbortSignal {
+    constructor() {
+        this._aborted = false;
+        this.listeners = new Map();
+    }
+    get aborted() {
+        return this._aborted;
+    }
+    addEventListener(type, listener) {
+        let listeners = this.listeners.get(type);
+        if (!listeners) {
+            listeners = new Set();
+            this.listeners.set(type, listeners);
+        }
+        listeners.add(listener);
+    }
+    removeEventListener(type, listener) {
+        const listeners = this.listeners.get(type);
+        if (listeners) {
+            listeners.delete(listener);
+            if (listeners.size === 0) {
+                this.listeners.delete(type);
+            }
+        }
+    }
+    dispatchEvent(event) {
+        const listeners = this.listeners.get(event.type);
+        if (listeners) {
+            for (const listener of listeners) {
+                listener(this, event);
+            }
+        }
+        return !event.defaultPrevented;
+    }
+    abort() {
+        if (!this.aborted) {
+            this._aborted = true;
+            const abortEvent = new Event('abort');
+            this.dispatchEvent(abortEvent);
+        }
+    }
+}
+
 class AsyncWorkerPool {
     constructor(concurrency) {
         this.queue = [];
@@ -48412,51 +48460,57 @@ class AsyncWorkerPool {
         return new Promise((resolve, reject) => {
             this.queue.push({
                 ...work,
-                workFn: () => work.workFn().then(resolve).catch(reject),
+                workFn: (abortController) => work.workFn(abortController).then(resolve).catch(reject),
             });
             this.doWork();
         });
     }
-    async cancel() {
-        const promises = [];
-        const cancellingWork = [
-            ...this.activeWork.splice(0, this.activeWork.length),
-            ...this.queue.splice(0, this.queue.length),
-        ];
-        cancellingWork.forEach((work) => {
-            const { cancelFn } = work;
+    /**
+     * cancel all work in the queue and active work
+     * @returns true if all work was cancelled, false if any work could not be cancelled
+     */
+    cancel() {
+        let success = true;
+        for (const { cancelFn } of this.queue) {
             if (cancelFn) {
-                promises.push(cancelFn());
+                try {
+                    cancelFn();
+                }
+                catch (_a) {
+                    success = false;
+                }
             }
-        });
-        await promiseAllSettled(promises);
+        }
+        this.queue = [];
+        for (const { abortController, cancelFn } of this.activeWork) {
+            abortController.abort();
+            if (cancelFn) {
+                try {
+                    cancelFn();
+                }
+                catch (_b) {
+                    success = false;
+                }
+            }
+        }
+        this.activeWork = [];
+        return success;
     }
     doWork() {
         while (this.queue.length > 0 && this.activeWork.length < this.concurrency) {
             const work = this.queue.shift();
             if (work) {
-                this.activeWork.push(work);
+                const abortController = new LdsAbortController();
+                const newWork = { ...work, abortController };
+                this.activeWork.push(newWork);
                 const { workFn } = work;
-                workFn()
-                    .then()
-                    .finally(() => {
-                    this.activeWork = this.activeWork.filter((w) => w !== work);
+                workFn(abortController).finally(() => {
+                    this.activeWork = this.activeWork.filter((w) => w !== newWork);
                     this.doWork();
                 });
             }
         }
     }
-}
-function promiseAllSettled(promises) {
-    return Promise.all(promises.map((promise) => promise
-        .then((value) => ({
-        status: 'fulfilled',
-        value,
-    }))
-        .catch((reason) => ({
-        status: 'rejected',
-        reason,
-    }))));
 }
 
 /**
@@ -49758,9 +49812,8 @@ class AbstractResourceRequestActionHandler {
                 const { response, synchronousIngest } = entry;
                 synchronousIngest(response, action);
             }
-            // ingestAndBroadcastFunction can return Promise<void>, that's easiest
-            // to return since it's unused in this function
-            return Promise.resolve();
+            // must call base broadcast
+            return luvio.storeBroadcast();
         }, 
         // getTypeCacheKeysRecord uses the response, not the full path factory
         // so 2nd parameter will be unused
@@ -58858,9 +58911,10 @@ const DEFAULT_BATCH_SIZE = 500;
 const DEFAULT_CONCURRENCY = 6;
 class PrimingSession extends EventEmitter {
     constructor(config) {
+        var _a, _b;
         super();
-        this.batchSize = config.batchSize || DEFAULT_BATCH_SIZE;
-        this.concurrency = config.concurrency || DEFAULT_CONCURRENCY;
+        this.batchSize = (_a = config.batchSize) !== null && _a !== void 0 ? _a : DEFAULT_BATCH_SIZE;
+        this.concurrency = (_b = config.concurrency) !== null && _b !== void 0 ? _b : DEFAULT_CONCURRENCY;
         this.recordLoader = config.recordLoader;
         this.recordIngestor = config.recordIngestor;
         this.objectInfoLoader = config.objectInfoLoader;
@@ -58888,12 +58942,20 @@ class PrimingSession extends EventEmitter {
             this.enqueueBatches(availableBatches);
         }
     }
+    cancel() {
+        this.networkWorkerPool.cancel();
+    }
     // parallelizes batches of priming work
     enqueueBatches(batches) {
         for (const batch of batches) {
             this.networkWorkerPool.push({
-                workFn: () => {
-                    return this.recordLoader.fetchRecordData(batch).then(async (result) => {
+                workFn: (abortController) => {
+                    return this.recordLoader
+                        .fetchRecordData(batch, abortController)
+                        .then(async (result) => {
+                        if (abortController.signal.aborted) {
+                            return;
+                        }
                         if (result.ok === false) {
                             const { error } = result;
                             const primingError = error === 'network-error' ? 'service-unavailable' : 'unknown';
@@ -58917,6 +58979,9 @@ class PrimingSession extends EventEmitter {
                         this.recordIngestor
                             .insertRecords(records)
                             .then(({ written, conflicted }) => {
+                            if (abortController.signal.aborted) {
+                                return;
+                            }
                             // now that the records are persisted, emit the primed event
                             if (written.length > 0) {
                                 this.emit('primed', Array.from(written));
@@ -58933,6 +58998,13 @@ class PrimingSession extends EventEmitter {
                         });
                     });
                 },
+                cancelFn: () => {
+                    this.emit('error', {
+                        ids: batch.ids,
+                        code: 'canceled',
+                        message: `batch canceled`,
+                    });
+                },
             });
         }
     }
@@ -58958,8 +59030,6 @@ class PrimingSession extends EventEmitter {
 }
 
 const requiredPrefix = `required_`;
-// note this is automatically incremented by scripts/release/bump-api-version.js at each release
-const apiVersion = `v58.0`;
 const requiredFieldMap = {
     ApiName: 'ApiName',
     Id: 'Id',
@@ -58973,10 +59043,10 @@ class RecordLoaderGraphQL {
     constructor(networkAdapter) {
         this.networkAdapter = networkAdapter;
     }
-    async fetchRecordData(batch) {
+    async fetchRecordData(batch, abortController) {
         let rep;
         try {
-            rep = await this.callGraphQL(batch);
+            rep = await this.callGraphQL(batch, abortController);
         }
         catch (e) {
             return {
@@ -59018,25 +59088,9 @@ class RecordLoaderGraphQL {
             missingIds: Array.from(seenRecords),
         };
     }
-    async callGraphQL(batch) {
+    callGraphQL(batch, abortController) {
         const query = this.generateGraphQLQuery(batch.type, batch.fields);
-        const response = await this.networkAdapter({
-            baseUri: `/services/data/${apiVersion}`,
-            basePath: '/graphql',
-            method: 'POST',
-            priority: 'background',
-            body: {
-                query,
-                variables: {
-                    ids: batch.ids,
-                    first: batch.ids.length,
-                },
-            },
-            queryParams: {},
-            urlParams: {},
-            headers: {},
-        }, {});
-        return response.body;
+        return this.networkAdapter.postGraphQL(query, { ids: batch.ids, first: batch.ids.length }, abortController);
     }
     generateGraphQLQuery(type, fields) {
         const fieldList = Object.keys(requiredFieldMap)
@@ -59171,8 +59225,57 @@ function instrumentPrimingSession(session) {
     return session;
 }
 
+// so eslint doesn't complain about nimbus
+/* global __nimbus */
+// note this is automatically incremented by scripts/release/bump-api-version.js at each release
+const apiVersion = `v58.0`;
+class NimbusPrimingNetworkAdapter {
+    postGraphQL(query, variables, abortController) {
+        return new Promise((resolve, reject) => {
+            let listener;
+            const unregisterListener = () => {
+                if (listener) {
+                    abortController.signal.removeEventListener('abort', listener);
+                }
+            };
+            __nimbus.plugins.LdsNetworkAdapter
+                .sendRequest({
+                method: 'POST',
+                path: `/services/data/${apiVersion}/graphql`,
+                body: JSON.stringify({
+                    query,
+                    variables,
+                }),
+                headers: {},
+                queryParams: {},
+                priority: 'background',
+                observabilityContext: {},
+            }, (response) => {
+                unregisterListener();
+                const { body } = response;
+                if (body) {
+                    resolve(JSON.parse(body));
+                }
+                else {
+                    reject(new Error('No body returned from graphql endpoint'));
+                }
+            }, (error) => {
+                unregisterListener();
+                reject(error);
+            })
+                .then((cancellationToken) => {
+                listener = () => {
+                    __nimbus.plugins.LdsNetworkAdapter.cancelRequest(cancellationToken);
+                };
+                abortController.signal.addEventListener('abort', listener);
+            });
+        });
+    }
+}
+
 function primingSessionFactory(config) {
-    const { networkAdapter, store, objectInfoService, getLuvio } = config;
+    const { store, objectInfoService, getLuvio } = config;
+    const networkAdapter = new NimbusPrimingNetworkAdapter();
     const recordLoader = new RecordLoaderGraphQL(networkAdapter);
     const recordIngestor = new RecordIngestor(store, getLuvio);
     const session = new PrimingSession({
@@ -59297,7 +59400,6 @@ function getRuntime() {
         createPrimingSession: (config) => {
             return primingSessionFactory({
                 store: lazyBaseDurableStore,
-                networkAdapter: lazyNetworkAdapter,
                 objectInfoService: lazyObjectInfoService,
                 getLuvio: () => lazyLuvio,
                 concurrency: config.concurrency,
@@ -59318,7 +59420,7 @@ register({
     id: '@salesforce/lds-network-adapter',
     instrument: instrument$1,
 });
-// version: 1.110.1-cc1242727
+// version: 1.111.0-f30e5e921
 
 const { create: create$2, keys: keys$2 } = Object;
 const { stringify: stringify$1, parse: parse$1 } = JSON;
@@ -59591,6 +59693,26 @@ function tokenFromOffset(paginationMetadata, offset) {
         }
     }
 }
+function tokenForAtMost(paginationMetadata, maxOffset) {
+    const tokens = Object.keys(paginationMetadata);
+    let tokenResult = undefined;
+    let offsetResult = -1;
+    for (let i = 0, len = tokens.length; i < len; i++) {
+        const token = tokens[i];
+        const offset = paginationMetadata[token];
+        if (token === '__END__' || offset === undefined) {
+            continue;
+        }
+        if (offset === maxOffset) {
+            return [token, offset];
+        }
+        if (offset < maxOffset && offset > offsetResult) {
+            tokenResult = token;
+            offsetResult = offset;
+        }
+    }
+    return [tokenResult, offsetResult];
+}
 function trimEdges(edges, startOffset, endOffset) {
     const trimmedEdges = [];
     if (edges !== undefined) {
@@ -59602,6 +59724,35 @@ function trimEdges(edges, startOffset, endOffset) {
         }
     }
     return trimmedEdges;
+}
+function optimizePagination(metadata, firstArgName, afterArgName, variables) {
+    if (typeof metadata === 'object' && metadata !== null && offsetFromToken(metadata, variables[afterArgName]) >= 0) {
+        // optimize only if after cursor is unspecified in the request or it's already loaded in metadata
+        const length = Object.keys(metadata).length;
+        const lastTokenAndOffset = tokenForAtMost(metadata, length);
+        if (lastTokenAndOffset !== undefined) {
+            const [token, offset] = lastTokenAndOffset;
+            variables[firstArgName + '_original'] = variables[firstArgName];
+            variables[afterArgName + '_original'] = variables[afterArgName];
+            variables[firstArgName] -= variables[afterArgName] === null ? (offset + 1) : (offset - 1);
+            variables[afterArgName] = token;
+        }
+    }
+}
+function revertPaginationOptimization(variables) {
+    if (variables) {
+        const toBeRemoved = [];
+        for (const key in variables) {
+            if (key.endsWith('_original')) {
+                const origKey = key.substring(0, key.length - '_original'.length);
+                if (Object.prototype.hasOwnProperty.call(variables, origKey)) {
+                    variables[origKey] = variables[key];
+                    toBeRemoved.push(key);
+                }
+            }
+        }
+        toBeRemoved.forEach((k) => delete variables[k]);
+    }
 }
 
 function applyToSelection$6(selection, directive, variables) {
@@ -66212,7 +66363,7 @@ function ingest$i(astNode, state) {
     });
 }
 function selectType$h(typename, sel, fieldData, reader, key, sink, variables, fragments) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     if (fieldData === null) {
         reader.assignScalar(key, sink, fieldData);
         return sink;
@@ -66870,6 +67021,10 @@ function selectType$h(typename, sel, fieldData, reader, key, sink, variables, fr
                         if (trimmedEdges === undefined || !listHasEnoughItems) {
                             reader.markMissingLink(fieldData.__ref);
                             reader.markMissing();
+                            // optimize pagination when "first" and "after" args are part of the variable
+                            if (((_c = firstArg === null || firstArg === void 0 ? void 0 : firstArg.value) === null || _c === void 0 ? void 0 : _c.kind) === 'Variable' && ((_d = afterArg === null || afterArg === void 0 ? void 0 : afterArg.value) === null || _d === void 0 ? void 0 : _d.kind) === 'Variable') {
+                                optimizePagination(metadata, firstArg.value.name.value, afterArg.value.name.value, variables);
+                            }
                             return;
                         }
                     }
@@ -66883,7 +67038,7 @@ function selectType$h(typename, sel, fieldData, reader, key, sink, variables, fr
                 const result = select$o(sel, variables, fragments)(paginatedData, reader);
                 const pageInfo = createPageInfo(result === null || result === void 0 ? void 0 : result.edges, startOffset, endOffset, maxOffset, metadata);
                 if (pageInfo !== undefined) {
-                    const selectedPageInfo = selectPageInfo$1((_c = sel.selectionSet) === null || _c === void 0 ? void 0 : _c.selections, fragments, pageInfo);
+                    const selectedPageInfo = selectPageInfo$1((_e = sel.selectionSet) === null || _e === void 0 ? void 0 : _e.selections, fragments, pageInfo);
                     if (selectedPageInfo !== undefined) {
                         reader.assignNonScalar(result, 'pageInfo', selectedPageInfo);
                     }
@@ -68514,7 +68669,7 @@ function getFieldData$e(source, sel, variables) {
     }
 }
 function selectType$e(typename, sel, fieldData, reader, key, sink, variables, fragments) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     if (fieldData === null) {
         reader.assignScalar(key, sink, fieldData);
         return sink;
@@ -68592,6 +68747,10 @@ function selectType$e(typename, sel, fieldData, reader, key, sink, variables, fr
                         if (trimmedEdges === undefined || !listHasEnoughItems) {
                             reader.markMissingLink(fieldData.__ref);
                             reader.markMissing();
+                            // optimize pagination when "first" and "after" args are part of the variable
+                            if (((_c = firstArg === null || firstArg === void 0 ? void 0 : firstArg.value) === null || _c === void 0 ? void 0 : _c.kind) === 'Variable' && ((_d = afterArg === null || afterArg === void 0 ? void 0 : afterArg.value) === null || _d === void 0 ? void 0 : _d.kind) === 'Variable') {
+                                optimizePagination(metadata, firstArg.value.name.value, afterArg.value.name.value, variables);
+                            }
                             return;
                         }
                     }
@@ -68605,7 +68764,7 @@ function selectType$e(typename, sel, fieldData, reader, key, sink, variables, fr
                 const result = select$o(sel, variables, fragments)(paginatedData, reader);
                 const pageInfo = createPageInfo(result === null || result === void 0 ? void 0 : result.edges, startOffset, endOffset, maxOffset, metadata);
                 if (pageInfo !== undefined) {
-                    const selectedPageInfo = selectPageInfo((_c = sel.selectionSet) === null || _c === void 0 ? void 0 : _c.selections, fragments, pageInfo);
+                    const selectedPageInfo = selectPageInfo((_e = sel.selectionSet) === null || _e === void 0 ? void 0 : _e.selections, fragments, pageInfo);
                     if (selectedPageInfo !== undefined) {
                         reader.assignNonScalar(result, 'pageInfo', selectedPageInfo);
                     }
@@ -75018,7 +75177,8 @@ function serializeValueNode$1(valueNode, variables) {
                 return aVal < bVal ? -1 : (aVal > bVal) ? 1 : 0;
             }).map((val, i) => serializeValueNode$1(val, variables) + `[${i}]`).join(',');
         case ("Variable"):
-            return variables[valueNode.name.value] + ""; //TODO: Is this correct serialization for object type variables?
+            const variableValue = variables[valueNode.name.value];
+            return typeof variableValue === "string" ? variableValue : JSON.stringify(variableValue);
         case ("NullValue"):
             return "null";
         case ("ObjectValue"):
@@ -75789,6 +75949,9 @@ function ingestSuccess$1(luvio, config, resourceParams, response, snapshotRefres
     const key = keyBuilder$3();
     const { query, variables } = resourceParams.body;
     luvio.storeIngest(key, ingest(query, variables), body);
+    // revert the optimized pagination variables back to its original so that subsequent store lookup will include all records, not just the ones loaded by an optimized query
+    // see optimizePagination for initial update to optimize the query
+    revertPaginationOptimization(variables);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select$7(luvio, config),
@@ -76971,7 +77134,7 @@ register({
     configuration: { ...configurationForGraphQLAdapters },
     instrument,
 });
-// version: 1.110.1-cc1242727
+// version: 1.111.0-f30e5e921
 
 // On core the unstable adapters are re-exported with different names,
 
@@ -79100,7 +79263,7 @@ withDefaultLuvio((luvio) => {
     unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
     graphQLImperative = ldsAdapter;
 });
-// version: 1.110.1-cc1242727
+// version: 1.111.0-f30e5e921
 
 var gqlApi = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -79766,6 +79929,7 @@ function createPrimingSession(config) {
     }
     return {
         enqueue: session.enqueue.bind(session),
+        cancel: session.cancel.bind(session),
     };
 }
 
@@ -79774,4 +79938,4 @@ const { luvio } = getRuntime();
 setDefaultLuvio({ luvio });
 
 export { createPrimingSession, draftManager, draftQueue, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, invokeAdapter, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, registerReportObserver, setMetadataTTL, setUiApiRecordTTL, subscribeToAdapter };
-// version: 1.110.1-cc1242727
+// version: 1.111.0-f30e5e921

package/dist/standalone/es/primingApi.d.ts

@@ -3,7 +3,7 @@ interface PrimingError {
     code: ErrorCode;
     message: string;
 }
-type ErrorCode = 'precondition-error' | 'not-found' | 'service-unavailable' | 'unknown';
+type ErrorCode = 'precondition-error' | 'not-found' | 'service-unavailable' | 'canceled' | 'unknown';
 interface PrimingEventHandler {
     onError?: (error: PrimingError) => void;
     onPrimed?: (ids: string[]) => void;
@@ -15,5 +15,6 @@ export interface PrimingSessionConfig {
 }
 export declare function createPrimingSession(config: PrimingSessionConfig): {
     enqueue: (work: PrimingWork) => Promise<void>;
+    cancel: () => void;
 };
 export {};