@salesforce/lds-worker-api 1.156.0 → 1.157.0

package/dist/sfdc/es/ldsWorkerApi.js

@@ -770,4 +770,4 @@ if (process.env.NODE_ENV !== 'production') {
 }
 
 export { createPrimingSession, draftManager, draftQueue, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, invokeAdapter, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, setMetadataTTL, setUiApiRecordTTL, subscribeToAdapter };
-// version: 1.156.0-edce97283
+// version: 1.157.0-4246d2656

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

@@ -3799,7 +3799,7 @@ function withDefaultLuvio(callback) {
     }
     callbacks.push(callback);
 }
-// version: 1.156.0-edce97283
+// version: 1.157.0-4246d2656
 
 // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
 function instrumentAdapter$1(createFunction, _metadata) {
@@ -15232,7 +15232,7 @@ function parseAndVisit(source) {
     updateReferenceMapWithKnownKey(ast, luvioDocumentNode);
     return luvioDocumentNode;
 }
-// version: 1.156.0-edce97283
+// version: 1.157.0-4246d2656
 
 function unwrap(data) {
     // The lwc-luvio bindings import a function from lwc called "unwrap".
@@ -16145,7 +16145,7 @@ function createGraphQLWireAdapterConstructor(luvio, adapter, metadata, astResolv
     const { apiFamily, name } = metadata;
     return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
 }
-// version: 1.156.0-edce97283
+// version: 1.157.0-4246d2656
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -44016,7 +44016,7 @@ withDefaultLuvio((luvio) => {
         dropFunction: instrumentation$2.notifyRecordUpdateAvailableDropped,
     });
 });
-// version: 1.156.0-82f95c630
+// version: 1.157.0-612ff940a
 
 var caseSensitiveUserId = '005B0000000GR4OIAW';
 
@@ -44118,6 +44118,15 @@ var eagerEvalDefaultCachePolicy = {
     },
 };
 
+var ldsPrimingGraphqlBatch = {
+    isOpen: function (e) {
+        return e.fallback;
+    },
+    hasError: function () {
+        return !0;
+    },
+};
+
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
  * All rights reserved.
@@ -48132,38 +48141,32 @@ function recordQuery(selection, apiName, alias, predicates, input) {
     const draftsField = { type: FieldType.Scalar, extract, path: 'node._drafts' };
     const idExtract = { type: ValueType.Extract, jsonAlias: alias, field: 'Id' };
     const idField = { type: FieldType.Scalar, extract: idExtract, path: 'node.Id' };
-    // When the exclude stale records gate is open, inject an additional predicate
-    // to limit the search to records that either have drafts associated to them or
-    // were ingested at least as recently as the query.
-    if (excludeStaleRecordsGate.isOpen({ fallback: false })) {
-        const key = input.connectionKeyBuilder(selection, input.config.variables);
-        const queryMetadata = input.metadata[key];
-        // If there is no metadata for this query or it somehow lacks a timestamp
-        // skip adding the additional predicates
-        if (queryMetadata !== undefined && queryMetadata.ingestionTimestamp !== undefined) {
-            const timestamp = queryMetadata.ingestionTimestamp;
-            const timestampCheck = {
-                type: PredicateType$1.comparison,
-                left: {
-                    type: ValueType.Extract,
-                    jsonAlias: alias,
-                    field: 'ingestionTimestamp',
-                    metadata: true,
-                },
-                operator: ComparisonOperator.gte,
-                right: { type: ValueType.IntLiteral, value: timestamp },
-            };
-            const isDraft = {
-                type: PredicateType$1.nullComparison,
-                left: { type: ValueType.Extract, jsonAlias: alias, field: 'drafts' },
-                operator: NullComparisonOperator.isNot,
-            };
-            predicates.push({
-                type: PredicateType$1.compound,
-                operator: CompoundOperator.or,
-                children: [timestampCheck, isDraft],
-            });
-        }
+    // When the exclude stale records gate is open and there is a root timestamp
+    // in the parser input, inject an additional predicate to limit the search
+    // to records that either have drafts associated to them or were ingested at
+    // least as recently as the query.
+    if (excludeStaleRecordsGate.isOpen({ fallback: false }) && input.rootTimestamp !== undefined) {
+        const timestampCheck = {
+            type: PredicateType$1.comparison,
+            left: {
+                type: ValueType.Extract,
+                jsonAlias: alias,
+                field: 'ingestionTimestamp',
+                metadata: true,
+            },
+            operator: ComparisonOperator.gte,
+            right: { type: ValueType.IntLiteral, value: input.rootTimestamp },
+        };
+        const isDraft = {
+            type: PredicateType$1.nullComparison,
+            left: { type: ValueType.Extract, jsonAlias: alias, field: 'drafts' },
+            operator: NullComparisonOperator.isNot,
+        };
+        predicates.push({
+            type: PredicateType$1.compound,
+            operator: CompoundOperator.or,
+            children: [timestampCheck, isDraft],
+        });
     }
     return queryContainer(internalFields, alias, apiName, predicates).map((result) => {
         const { fields, predicates } = result;
@@ -48213,6 +48216,20 @@ function rootRecordQuery(selection, input) {
     if (input.objectInfoMap[alias] === undefined) {
         return failure([missingObjectInfo(apiName)]);
     }
+    // When the exclude stale records gate is open and the query has an
+    // ingestion timestamp in its cache metadata, associate that with the input
+    // so it can later be used to limit the search to records were ingested at
+    // least as recently as the query.
+    if (excludeStaleRecordsGate.isOpen({ fallback: false })) {
+        const key = input.connectionKeyBuilder(selection, input.config.variables);
+        const queryMetadata = input.metadata[key];
+        // If there is no metadata for this query or it somehow lacks a timestamp
+        // skip setting the root timestamp
+        if (queryMetadata !== undefined && queryMetadata.ingestionTimestamp !== undefined) {
+            // subtract 10ms from timestamp to account for ingestion processing time
+            input.rootTimestamp = queryMetadata.ingestionTimestamp - 10;
+        }
+    }
     return recordQuery(selection, alias, apiName, [], input);
 }
 function rootQuery(recordNodes, input) {
@@ -53109,7 +53126,7 @@ function dataTypeToType(objectInfoDataType, apiName) {
         case 'Url':
             return 'UrlValue';
         case 'Picklist':
-            return 'UrlValue';
+            return 'PicklistValue';
         case 'MultiPicklist':
             return 'MultiPicklistValue';
         case 'Percent':
@@ -59293,16 +59310,19 @@ function generateTypedBatches(work, batchSize) {
 
 const DEFAULT_BATCH_SIZE = 500;
 const DEFAULT_CONCURRENCY = 6;
+const DEFAULT_GQL_QUERY_BATCH_SIZE = 5;
 class PrimingSession extends EventEmitter {
     constructor(config) {
         var _a, _b;
         super();
+        this.useBatchGQL = false;
         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;
         this.networkWorkerPool = new AsyncWorkerPool(this.concurrency);
+        this.useBatchGQL = ldsPrimingGraphqlBatch.isOpen({ fallback: false });
     }
     // function that enqueues priming work
     async enqueue(work) {
@@ -59337,91 +59357,129 @@ class PrimingSession extends EventEmitter {
     }
     // parallelizes batches of priming work
     enqueueBatches(batches) {
-        for (const batch of batches) {
-            const queuedTime = Date.now();
-            this.networkWorkerPool.push({
-                workFn: (abortController) => {
-                    const workTime = Date.now();
-                    this.emit('batch-starting', { queuedTime: workTime - queuedTime });
-                    return this.recordLoader
-                        .fetchRecordData(batch, abortController)
-                        .then(async (result) => {
-                        if (abortController.aborted) {
-                            return;
-                        }
-                        this.emit('batch-fetched', {
+        if (this.useBatchGQL === false) {
+            for (const batch of batches) {
+                const queuedTime = Date.now();
+                this.networkWorkerPool.push({
+                    workFn: (abortController) => {
+                        const workTime = Date.now();
+                        this.emit('batch-starting', { queuedTime: workTime - queuedTime });
+                        return this.recordLoader
+                            .fetchRecordData(batch, abortController)
+                            .then(async (result) => {
+                            this.emit('batch-fetched', {
+                                ids: batch.ids,
+                                duration: Date.now() - workTime,
+                            });
+                            this.processFetchedRecords(result, abortController);
+                        });
+                    },
+                    cancelFn: () => {
+                        this.emit('error', {
                             ids: batch.ids,
-                            duration: Date.now() - workTime,
+                            code: 'canceled',
+                            message: `batch canceled`,
                         });
-                        if (result.ok === false) {
-                            const { error } = result;
-                            const primingError = error === 'network-error' ? 'service-unavailable' : 'unknown';
-                            this.emit('error', {
-                                ids: result.missingIds,
-                                code: primingError,
-                                message: `${result.messages.join(',')}`,
-                            });
-                            return;
-                        }
-                        const { missingIds } = result;
-                        if (missingIds.length > 0) {
-                            this.emit('error', {
-                                ids: missingIds,
-                                code: 'not-found',
-                                message: `could not find records: ${missingIds.join(', ')}`,
-                            });
-                        }
-                        const { records } = result;
-                        const beforeWrite = Date.now();
-                        // dispatch the write but DO NOT wait on it to unblock the network pool
-                        this.recordIngestor
-                            .insertRecords(records)
-                            .then(({ written, conflicted, errors }) => {
-                            this.emit('batch-written', {
-                                written,
-                                conflicted,
-                                errors: errors
-                                    .map((e) => e.ids)
-                                    .reduce((a, b) => a.concat(b), []),
-                                duration: Date.now() - beforeWrite,
-                            });
+                    },
+                });
+            }
+        }
+        else {
+            const chucks = chunk(batches, DEFAULT_GQL_QUERY_BATCH_SIZE);
+            for (const batchChuck of chucks) {
+                const queuedTime = Date.now();
+                this.networkWorkerPool.push({
+                    workFn: (abortController) => {
+                        const workTime = Date.now();
+                        this.emit('batch-starting', { queuedTime: workTime - queuedTime });
+                        return this.recordLoader
+                            .batchFetchRecordData(batchChuck, abortController)
+                            .then(async (results) => {
                             if (abortController.aborted) {
                                 return;
                             }
-                            if (errors.length > 0) {
-                                errors.forEach(({ ids, message }) => {
-                                    this.emit('error', {
-                                        ids,
-                                        code: 'unknown',
-                                        message: message,
-                                    });
+                            const duration = Date.now() - workTime;
+                            // For each query within the Batch gql query, result returns at the same time
+                            for (let i = 0; i < results.length; i++) {
+                                this.emit('batch-fetched', {
+                                    ids: batchChuck[i].ids,
+                                    duration,
                                 });
                             }
-                            // now that the records are persisted, emit the primed event
-                            if (written.length > 0) {
-                                this.emit('primed', Array.from(written));
-                            }
-                            // TODO [W-12436213]: implement conflict resolution
-                            if (conflicted.length > 0) {
-                                // for now emit conlicts as errors
-                                this.emit('error', {
-                                    ids: Array.from(conflicted),
-                                    code: 'unknown',
-                                    message: 'conflict when persisting record',
-                                });
+                            for (let i = 0; i < results.length; i++) {
+                                this.processFetchedRecords(results[i], abortController);
                             }
                         });
-                    });
-                },
-                cancelFn: () => {
-                    this.emit('error', {
-                        ids: batch.ids,
-                        code: 'canceled',
-                        message: `batch canceled`,
-                    });
-                },
+                    },
+                    cancelFn: () => {
+                        const chuckIds = batchChuck
+                            .map((batch) => batch.ids)
+                            .reduce((prev, curr) => prev.concat(curr), []);
+                        this.emit('error', {
+                            ids: chuckIds,
+                            code: 'canceled',
+                            message: `batch canceled`,
+                        });
+                    },
+                });
+            }
+        }
+    }
+    processFetchedRecords(result, abortController) {
+        if (result.ok === false) {
+            const { error } = result;
+            const primingError = error === 'network-error' ? 'service-unavailable' : 'unknown';
+            this.emit('error', {
+                ids: result.missingIds,
+                code: primingError,
+                message: `${result.messages.join(',')}`,
+            });
+            return;
+        }
+        const { missingIds } = result;
+        if (missingIds.length > 0) {
+            this.emit('error', {
+                ids: missingIds,
+                code: 'not-found',
+                message: `could not find records: ${missingIds.join(', ')}`,
             });
         }
+        const { records } = result;
+        const beforeWrite = Date.now();
+        // dispatch the write but DO NOT wait on it to unblock the network pool
+        this.recordIngestor.insertRecords(records).then(({ written, conflicted, errors }) => {
+            this.emit('batch-written', {
+                written,
+                conflicted,
+                errors: errors.map((e) => e.ids).reduce((a, b) => a.concat(b), []),
+                duration: Date.now() - beforeWrite,
+            });
+            if (abortController.aborted) {
+                return;
+            }
+            if (errors.length > 0) {
+                errors.forEach(({ ids, message }) => {
+                    this.emit('error', {
+                        ids,
+                        code: 'unknown',
+                        message: message,
+                    });
+                });
+            }
+            // now that the records are persisted, emit the primed event
+            if (written.length > 0) {
+                this.emit('primed', Array.from(written));
+            }
+            // TODO [W-12436213]: implement conflict resolution
+            if (conflicted.length > 0) {
+                // for now emit conlicts as errors
+                this.emit('error', {
+                    ids: Array.from(conflicted),
+                    code: 'unknown',
+                    message: 'conflict when persisting record',
+                });
+            }
+        });
     }
     async fetchMetadata(batches) {
         const apiNames = Array.from(batches.reduce((acc, x) => {
@@ -59474,12 +59532,39 @@ class RecordLoaderGraphQL {
                 missingIds: batch.ids,
             };
         }
-        const { data, errors } = rep;
+        return this.generateFetchResult(rep, batch);
+    }
+    async batchFetchRecordData(batchs, abortController) {
+        let reps;
+        try {
+            reps = await this.callBatchGraphQL(batchs, abortController);
+        }
+        catch (e) {
+            const missingIds = batchs
+                .map((batch) => batch.ids)
+                .reduce((prev, curr) => prev.concat(curr), []);
+            return [
+                {
+                    ok: false,
+                    error: 'network-error',
+                    messages: ['Network Error'],
+                    missingIds,
+                },
+            ];
+        }
+        const recordFetchResults = [];
+        for (let i = 0; i < reps.length; i++) {
+            recordFetchResults.push(this.generateFetchResult(reps[i], batchs[i]));
+        }
+        return recordFetchResults;
+    }
+    generateFetchResult(repResult, batchInput) {
+        const { data, errors } = repResult;
         if (errors !== undefined && errors.length > 0) {
             // right now if there are any errors in the batch we throw out the entire batch
             // for now this is ok all errors will originate on the same node so there shouldn't be a mix of errors and data
             return {
-                missingIds: batch.ids,
+                missingIds: batchInput.ids,
                 ok: false,
                 error: 'request-error',
                 messages: errors.map((x) => x.message),
@@ -59491,11 +59576,11 @@ class RecordLoaderGraphQL {
                 ok: false,
                 error: 'unknown',
                 messages: ['unexpected response retrieved from graphql endpoint'],
-                missingIds: batch.ids,
+                missingIds: batchInput.ids,
             };
         }
-        const seenRecords = new Set(batch.ids);
-        const records = data.uiapi.query[batch.type].edges.map((edge) => {
+        const seenRecords = new Set(batchInput.ids);
+        const records = data.uiapi.query[batchInput.type].edges.map((edge) => {
             const record = this.generateDurableRecordRepresentation(edge.node);
             seenRecords.delete(record.id);
             return record;
@@ -59510,6 +59595,15 @@ class RecordLoaderGraphQL {
         const query = this.generateGraphQLQuery(batch.type, batch.fields);
         return this.networkAdapter.postGraphQL(query, { ids: batch.ids, first: batch.ids.length }, abortController);
     }
+    callBatchGraphQL(batches, abortController) {
+        const gqlInput = batches.map((batch) => {
+            return {
+                query: this.generateGraphQLQuery(batch.type, batch.fields),
+                variables: { ids: batch.ids, first: batch.ids.length },
+            };
+        });
+        return this.networkAdapter.postBatchGraphQL(gqlInput, abortController);
+    }
     generateGraphQLQuery(type, fields) {
         const fieldList = Object.keys(requiredFieldMap)
             .map((field) => {
@@ -59631,7 +59725,56 @@ function instrumentPrimingSession(session) {
 /* global __nimbus */
 // note this is automatically incremented by scripts/release/bump-api-version.js at each release
 const apiVersion = `v59.0`;
+const batchEndPointPath = `/services/data/${apiVersion}/graphql/batch`;
+const endPointPath = `/services/data/${apiVersion}/graphql`;
 class NimbusPrimingNetworkAdapter {
+    postBatchGraphQL(configs, abortController) {
+        return new Promise((resolve, reject) => {
+            let listener;
+            const unregisterListener = () => {
+                if (listener) {
+                    abortController.removeEventListener(listener);
+                }
+            };
+            __nimbus.plugins.LdsNetworkAdapter
+                .sendRequest({
+                method: 'POST',
+                path: batchEndPointPath,
+                body: JSON.stringify({
+                    batchQuery: configs,
+                }),
+                headers: {},
+                queryParams: {},
+                priority: 'background',
+                observabilityContext: {},
+            }, (response) => {
+                unregisterListener();
+                const { body } = response;
+                if (body) {
+                    const { results } = JSON.parse(body);
+                    if (results) {
+                        const gqlResults = results.map((compositeGqlResult) => compositeGqlResult.result);
+                        resolve(gqlResults);
+                    }
+                    else {
+                        reject(new Error(`No body returned from ${batchEndPointPath} endpoint`));
+                    }
+                }
+                else {
+                    reject(new Error(`No body returned from ${batchEndPointPath} endpoint`));
+                }
+            }, (error) => {
+                unregisterListener();
+                reject(error);
+            })
+                .then((cancellationToken) => {
+                listener = () => {
+                    __nimbus.plugins.LdsNetworkAdapter.cancelRequest(cancellationToken);
+                };
+                abortController.addEventListener(listener);
+            });
+        });
+    }
     postGraphQL(query, variables, abortController) {
         return new Promise((resolve, reject) => {
             let listener;
@@ -59643,7 +59786,7 @@ class NimbusPrimingNetworkAdapter {
             __nimbus.plugins.LdsNetworkAdapter
                 .sendRequest({
                 method: 'POST',
-                path: `/services/data/${apiVersion}/graphql`,
+                path: endPointPath,
                 body: JSON.stringify({
                     query,
                     variables,
@@ -59659,7 +59802,7 @@ class NimbusPrimingNetworkAdapter {
                     resolve(JSON.parse(body));
                 }
                 else {
-                    reject(new Error('No body returned from graphql endpoint'));
+                    reject(new Error(`No body returned from ${endPointPath} endpoint`));
                 }
             }, (error) => {
                 unregisterListener();
@@ -59907,7 +60050,7 @@ register({
     id: '@salesforce/lds-network-adapter',
     instrument: instrument$1,
 });
-// version: 1.156.0-edce97283
+// version: 1.157.0-4246d2656
 
 const { create: create$2, keys: keys$2 } = Object;
 const { stringify: stringify$1, parse: parse$1 } = JSON;
@@ -80752,7 +80895,7 @@ register({
     configuration: { ...configurationForGraphQLAdapters },
     instrument,
 });
-// version: 1.156.0-82f95c630
+// version: 1.157.0-612ff940a
 
 // On core the unstable adapters are re-exported with different names,
 
@@ -82999,7 +83142,7 @@ withDefaultLuvio((luvio) => {
     unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
     graphQLImperative = ldsAdapter;
 });
-// version: 1.156.0-82f95c630
+// version: 1.157.0-612ff940a
 
 var gqlApi = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -83688,4 +83831,4 @@ const { luvio } = getRuntime();
 setDefaultLuvio({ luvio });
 
 export { createPrimingSession, draftManager, draftQueue, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, invokeAdapter, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, registerReportObserver, setMetadataTTL, setUiApiRecordTTL, subscribeToAdapter };
-// version: 1.156.0-edce97283
+// version: 1.157.0-4246d2656

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

@@ -3805,7 +3805,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.156.0-edce97283
+    // version: 1.157.0-4246d2656
 
     // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
     function instrumentAdapter$1(createFunction, _metadata) {
@@ -15238,7 +15238,7 @@
         updateReferenceMapWithKnownKey(ast, luvioDocumentNode);
         return luvioDocumentNode;
     }
-    // version: 1.156.0-edce97283
+    // version: 1.157.0-4246d2656
 
     function unwrap(data) {
         // The lwc-luvio bindings import a function from lwc called "unwrap".
@@ -16151,7 +16151,7 @@
         const { apiFamily, name } = metadata;
         return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
     }
-    // version: 1.156.0-edce97283
+    // version: 1.157.0-4246d2656
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -44022,7 +44022,7 @@
             dropFunction: instrumentation$2.notifyRecordUpdateAvailableDropped,
         });
     });
-    // version: 1.156.0-82f95c630
+    // version: 1.157.0-612ff940a
 
     var caseSensitiveUserId = '005B0000000GR4OIAW';
 
@@ -44124,6 +44124,15 @@
         },
     };
 
+    var ldsPrimingGraphqlBatch = {
+        isOpen: function (e) {
+            return e.fallback;
+        },
+        hasError: function () {
+            return !0;
+        },
+    };
+
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
      * All rights reserved.
@@ -48138,38 +48147,32 @@
         const draftsField = { type: FieldType.Scalar, extract, path: 'node._drafts' };
         const idExtract = { type: ValueType.Extract, jsonAlias: alias, field: 'Id' };
         const idField = { type: FieldType.Scalar, extract: idExtract, path: 'node.Id' };
-        // When the exclude stale records gate is open, inject an additional predicate
-        // to limit the search to records that either have drafts associated to them or
-        // were ingested at least as recently as the query.
-        if (excludeStaleRecordsGate.isOpen({ fallback: false })) {
-            const key = input.connectionKeyBuilder(selection, input.config.variables);
-            const queryMetadata = input.metadata[key];
-            // If there is no metadata for this query or it somehow lacks a timestamp
-            // skip adding the additional predicates
-            if (queryMetadata !== undefined && queryMetadata.ingestionTimestamp !== undefined) {
-                const timestamp = queryMetadata.ingestionTimestamp;
-                const timestampCheck = {
-                    type: PredicateType$1.comparison,
-                    left: {
-                        type: ValueType.Extract,
-                        jsonAlias: alias,
-                        field: 'ingestionTimestamp',
-                        metadata: true,
-                    },
-                    operator: ComparisonOperator.gte,
-                    right: { type: ValueType.IntLiteral, value: timestamp },
-                };
-                const isDraft = {
-                    type: PredicateType$1.nullComparison,
-                    left: { type: ValueType.Extract, jsonAlias: alias, field: 'drafts' },
-                    operator: NullComparisonOperator.isNot,
-                };
-                predicates.push({
-                    type: PredicateType$1.compound,
-                    operator: CompoundOperator.or,
-                    children: [timestampCheck, isDraft],
-                });
-            }
+        // When the exclude stale records gate is open and there is a root timestamp
+        // in the parser input, inject an additional predicate to limit the search
+        // to records that either have drafts associated to them or were ingested at
+        // least as recently as the query.
+        if (excludeStaleRecordsGate.isOpen({ fallback: false }) && input.rootTimestamp !== undefined) {
+            const timestampCheck = {
+                type: PredicateType$1.comparison,
+                left: {
+                    type: ValueType.Extract,
+                    jsonAlias: alias,
+                    field: 'ingestionTimestamp',
+                    metadata: true,
+                },
+                operator: ComparisonOperator.gte,
+                right: { type: ValueType.IntLiteral, value: input.rootTimestamp },
+            };
+            const isDraft = {
+                type: PredicateType$1.nullComparison,
+                left: { type: ValueType.Extract, jsonAlias: alias, field: 'drafts' },
+                operator: NullComparisonOperator.isNot,
+            };
+            predicates.push({
+                type: PredicateType$1.compound,
+                operator: CompoundOperator.or,
+                children: [timestampCheck, isDraft],
+            });
         }
         return queryContainer(internalFields, alias, apiName, predicates).map((result) => {
             const { fields, predicates } = result;
@@ -48219,6 +48222,20 @@
         if (input.objectInfoMap[alias] === undefined) {
             return failure([missingObjectInfo(apiName)]);
         }
+        // When the exclude stale records gate is open and the query has an
+        // ingestion timestamp in its cache metadata, associate that with the input
+        // so it can later be used to limit the search to records were ingested at
+        // least as recently as the query.
+        if (excludeStaleRecordsGate.isOpen({ fallback: false })) {
+            const key = input.connectionKeyBuilder(selection, input.config.variables);
+            const queryMetadata = input.metadata[key];
+            // If there is no metadata for this query or it somehow lacks a timestamp
+            // skip setting the root timestamp
+            if (queryMetadata !== undefined && queryMetadata.ingestionTimestamp !== undefined) {
+                // subtract 10ms from timestamp to account for ingestion processing time
+                input.rootTimestamp = queryMetadata.ingestionTimestamp - 10;
+            }
+        }
         return recordQuery(selection, alias, apiName, [], input);
     }
     function rootQuery(recordNodes, input) {
@@ -53115,7 +53132,7 @@
             case 'Url':
                 return 'UrlValue';
             case 'Picklist':
-                return 'UrlValue';
+                return 'PicklistValue';
             case 'MultiPicklist':
                 return 'MultiPicklistValue';
             case 'Percent':
@@ -59299,16 +59316,19 @@
 
     const DEFAULT_BATCH_SIZE = 500;
     const DEFAULT_CONCURRENCY = 6;
+    const DEFAULT_GQL_QUERY_BATCH_SIZE = 5;
     class PrimingSession extends EventEmitter {
         constructor(config) {
             var _a, _b;
             super();
+            this.useBatchGQL = false;
             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;
             this.networkWorkerPool = new AsyncWorkerPool(this.concurrency);
+            this.useBatchGQL = ldsPrimingGraphqlBatch.isOpen({ fallback: false });
         }
         // function that enqueues priming work
         async enqueue(work) {
@@ -59343,91 +59363,129 @@
         }
         // parallelizes batches of priming work
         enqueueBatches(batches) {
-            for (const batch of batches) {
-                const queuedTime = Date.now();
-                this.networkWorkerPool.push({
-                    workFn: (abortController) => {
-                        const workTime = Date.now();
-                        this.emit('batch-starting', { queuedTime: workTime - queuedTime });
-                        return this.recordLoader
-                            .fetchRecordData(batch, abortController)
-                            .then(async (result) => {
-                            if (abortController.aborted) {
-                                return;
-                            }
-                            this.emit('batch-fetched', {
+            if (this.useBatchGQL === false) {
+                for (const batch of batches) {
+                    const queuedTime = Date.now();
+                    this.networkWorkerPool.push({
+                        workFn: (abortController) => {
+                            const workTime = Date.now();
+                            this.emit('batch-starting', { queuedTime: workTime - queuedTime });
+                            return this.recordLoader
+                                .fetchRecordData(batch, abortController)
+                                .then(async (result) => {
+                                this.emit('batch-fetched', {
+                                    ids: batch.ids,
+                                    duration: Date.now() - workTime,
+                                });
+                                this.processFetchedRecords(result, abortController);
+                            });
+                        },
+                        cancelFn: () => {
+                            this.emit('error', {
                                 ids: batch.ids,
-                                duration: Date.now() - workTime,
+                                code: 'canceled',
+                                message: `batch canceled`,
                             });
-                            if (result.ok === false) {
-                                const { error } = result;
-                                const primingError = error === 'network-error' ? 'service-unavailable' : 'unknown';
-                                this.emit('error', {
-                                    ids: result.missingIds,
-                                    code: primingError,
-                                    message: `${result.messages.join(',')}`,
-                                });
-                                return;
-                            }
-                            const { missingIds } = result;
-                            if (missingIds.length > 0) {
-                                this.emit('error', {
-                                    ids: missingIds,
-                                    code: 'not-found',
-                                    message: `could not find records: ${missingIds.join(', ')}`,
-                                });
-                            }
-                            const { records } = result;
-                            const beforeWrite = Date.now();
-                            // dispatch the write but DO NOT wait on it to unblock the network pool
-                            this.recordIngestor
-                                .insertRecords(records)
-                                .then(({ written, conflicted, errors }) => {
-                                this.emit('batch-written', {
-                                    written,
-                                    conflicted,
-                                    errors: errors
-                                        .map((e) => e.ids)
-                                        .reduce((a, b) => a.concat(b), []),
-                                    duration: Date.now() - beforeWrite,
-                                });
+                        },
+                    });
+                }
+            }
+            else {
+                const chucks = chunk(batches, DEFAULT_GQL_QUERY_BATCH_SIZE);
+                for (const batchChuck of chucks) {
+                    const queuedTime = Date.now();
+                    this.networkWorkerPool.push({
+                        workFn: (abortController) => {
+                            const workTime = Date.now();
+                            this.emit('batch-starting', { queuedTime: workTime - queuedTime });
+                            return this.recordLoader
+                                .batchFetchRecordData(batchChuck, abortController)
+                                .then(async (results) => {
                                 if (abortController.aborted) {
                                     return;
                                 }
-                                if (errors.length > 0) {
-                                    errors.forEach(({ ids, message }) => {
-                                        this.emit('error', {
-                                            ids,
-                                            code: 'unknown',
-                                            message: message,
-                                        });
+                                const duration = Date.now() - workTime;
+                                // For each query within the Batch gql query, result returns at the same time
+                                for (let i = 0; i < results.length; i++) {
+                                    this.emit('batch-fetched', {
+                                        ids: batchChuck[i].ids,
+                                        duration,
                                     });
                                 }
-                                // now that the records are persisted, emit the primed event
-                                if (written.length > 0) {
-                                    this.emit('primed', Array.from(written));
-                                }
-                                // TODO [W-12436213]: implement conflict resolution
-                                if (conflicted.length > 0) {
-                                    // for now emit conlicts as errors
-                                    this.emit('error', {
-                                        ids: Array.from(conflicted),
-                                        code: 'unknown',
-                                        message: 'conflict when persisting record',
-                                    });
+                                for (let i = 0; i < results.length; i++) {
+                                    this.processFetchedRecords(results[i], abortController);
                                 }
                             });
-                        });
-                    },
-                    cancelFn: () => {
-                        this.emit('error', {
-                            ids: batch.ids,
-                            code: 'canceled',
-                            message: `batch canceled`,
-                        });
-                    },
+                        },
+                        cancelFn: () => {
+                            const chuckIds = batchChuck
+                                .map((batch) => batch.ids)
+                                .reduce((prev, curr) => prev.concat(curr), []);
+                            this.emit('error', {
+                                ids: chuckIds,
+                                code: 'canceled',
+                                message: `batch canceled`,
+                            });
+                        },
+                    });
+                }
+            }
+        }
+        processFetchedRecords(result, abortController) {
+            if (result.ok === false) {
+                const { error } = result;
+                const primingError = error === 'network-error' ? 'service-unavailable' : 'unknown';
+                this.emit('error', {
+                    ids: result.missingIds,
+                    code: primingError,
+                    message: `${result.messages.join(',')}`,
+                });
+                return;
+            }
+            const { missingIds } = result;
+            if (missingIds.length > 0) {
+                this.emit('error', {
+                    ids: missingIds,
+                    code: 'not-found',
+                    message: `could not find records: ${missingIds.join(', ')}`,
                 });
             }
+            const { records } = result;
+            const beforeWrite = Date.now();
+            // dispatch the write but DO NOT wait on it to unblock the network pool
+            this.recordIngestor.insertRecords(records).then(({ written, conflicted, errors }) => {
+                this.emit('batch-written', {
+                    written,
+                    conflicted,
+                    errors: errors.map((e) => e.ids).reduce((a, b) => a.concat(b), []),
+                    duration: Date.now() - beforeWrite,
+                });
+                if (abortController.aborted) {
+                    return;
+                }
+                if (errors.length > 0) {
+                    errors.forEach(({ ids, message }) => {
+                        this.emit('error', {
+                            ids,
+                            code: 'unknown',
+                            message: message,
+                        });
+                    });
+                }
+                // now that the records are persisted, emit the primed event
+                if (written.length > 0) {
+                    this.emit('primed', Array.from(written));
+                }
+                // TODO [W-12436213]: implement conflict resolution
+                if (conflicted.length > 0) {
+                    // for now emit conlicts as errors
+                    this.emit('error', {
+                        ids: Array.from(conflicted),
+                        code: 'unknown',
+                        message: 'conflict when persisting record',
+                    });
+                }
+            });
         }
         async fetchMetadata(batches) {
             const apiNames = Array.from(batches.reduce((acc, x) => {
@@ -59480,12 +59538,39 @@
                     missingIds: batch.ids,
                 };
             }
-            const { data, errors } = rep;
+            return this.generateFetchResult(rep, batch);
+        }
+        async batchFetchRecordData(batchs, abortController) {
+            let reps;
+            try {
+                reps = await this.callBatchGraphQL(batchs, abortController);
+            }
+            catch (e) {
+                const missingIds = batchs
+                    .map((batch) => batch.ids)
+                    .reduce((prev, curr) => prev.concat(curr), []);
+                return [
+                    {
+                        ok: false,
+                        error: 'network-error',
+                        messages: ['Network Error'],
+                        missingIds,
+                    },
+                ];
+            }
+            const recordFetchResults = [];
+            for (let i = 0; i < reps.length; i++) {
+                recordFetchResults.push(this.generateFetchResult(reps[i], batchs[i]));
+            }
+            return recordFetchResults;
+        }
+        generateFetchResult(repResult, batchInput) {
+            const { data, errors } = repResult;
             if (errors !== undefined && errors.length > 0) {
                 // right now if there are any errors in the batch we throw out the entire batch
                 // for now this is ok all errors will originate on the same node so there shouldn't be a mix of errors and data
                 return {
-                    missingIds: batch.ids,
+                    missingIds: batchInput.ids,
                     ok: false,
                     error: 'request-error',
                     messages: errors.map((x) => x.message),
@@ -59497,11 +59582,11 @@
                     ok: false,
                     error: 'unknown',
                     messages: ['unexpected response retrieved from graphql endpoint'],
-                    missingIds: batch.ids,
+                    missingIds: batchInput.ids,
                 };
             }
-            const seenRecords = new Set(batch.ids);
-            const records = data.uiapi.query[batch.type].edges.map((edge) => {
+            const seenRecords = new Set(batchInput.ids);
+            const records = data.uiapi.query[batchInput.type].edges.map((edge) => {
                 const record = this.generateDurableRecordRepresentation(edge.node);
                 seenRecords.delete(record.id);
                 return record;
@@ -59516,6 +59601,15 @@
             const query = this.generateGraphQLQuery(batch.type, batch.fields);
             return this.networkAdapter.postGraphQL(query, { ids: batch.ids, first: batch.ids.length }, abortController);
         }
+        callBatchGraphQL(batches, abortController) {
+            const gqlInput = batches.map((batch) => {
+                return {
+                    query: this.generateGraphQLQuery(batch.type, batch.fields),
+                    variables: { ids: batch.ids, first: batch.ids.length },
+                };
+            });
+            return this.networkAdapter.postBatchGraphQL(gqlInput, abortController);
+        }
         generateGraphQLQuery(type, fields) {
             const fieldList = Object.keys(requiredFieldMap)
                 .map((field) => {
@@ -59637,7 +59731,56 @@
     /* global __nimbus */
     // note this is automatically incremented by scripts/release/bump-api-version.js at each release
     const apiVersion = `v59.0`;
+    const batchEndPointPath = `/services/data/${apiVersion}/graphql/batch`;
+    const endPointPath = `/services/data/${apiVersion}/graphql`;
     class NimbusPrimingNetworkAdapter {
+        postBatchGraphQL(configs, abortController) {
+            return new Promise((resolve, reject) => {
+                let listener;
+                const unregisterListener = () => {
+                    if (listener) {
+                        abortController.removeEventListener(listener);
+                    }
+                };
+                __nimbus.plugins.LdsNetworkAdapter
+                    .sendRequest({
+                    method: 'POST',
+                    path: batchEndPointPath,
+                    body: JSON.stringify({
+                        batchQuery: configs,
+                    }),
+                    headers: {},
+                    queryParams: {},
+                    priority: 'background',
+                    observabilityContext: {},
+                }, (response) => {
+                    unregisterListener();
+                    const { body } = response;
+                    if (body) {
+                        const { results } = JSON.parse(body);
+                        if (results) {
+                            const gqlResults = results.map((compositeGqlResult) => compositeGqlResult.result);
+                            resolve(gqlResults);
+                        }
+                        else {
+                            reject(new Error(`No body returned from ${batchEndPointPath} endpoint`));
+                        }
+                    }
+                    else {
+                        reject(new Error(`No body returned from ${batchEndPointPath} endpoint`));
+                    }
+                }, (error) => {
+                    unregisterListener();
+                    reject(error);
+                })
+                    .then((cancellationToken) => {
+                    listener = () => {
+                        __nimbus.plugins.LdsNetworkAdapter.cancelRequest(cancellationToken);
+                    };
+                    abortController.addEventListener(listener);
+                });
+            });
+        }
         postGraphQL(query, variables, abortController) {
             return new Promise((resolve, reject) => {
                 let listener;
@@ -59649,7 +59792,7 @@
                 __nimbus.plugins.LdsNetworkAdapter
                     .sendRequest({
                     method: 'POST',
-                    path: `/services/data/${apiVersion}/graphql`,
+                    path: endPointPath,
                     body: JSON.stringify({
                         query,
                         variables,
@@ -59665,7 +59808,7 @@
                         resolve(JSON.parse(body));
                     }
                     else {
-                        reject(new Error('No body returned from graphql endpoint'));
+                        reject(new Error(`No body returned from ${endPointPath} endpoint`));
                     }
                 }, (error) => {
                     unregisterListener();
@@ -59913,7 +60056,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$1,
     });
-    // version: 1.156.0-edce97283
+    // version: 1.157.0-4246d2656
 
     const { create: create$2, keys: keys$2 } = Object;
     const { stringify: stringify$1, parse: parse$1 } = JSON;
@@ -80758,7 +80901,7 @@
         configuration: { ...configurationForGraphQLAdapters },
         instrument,
     });
-    // version: 1.156.0-82f95c630
+    // version: 1.157.0-612ff940a
 
     // On core the unstable adapters are re-exported with different names,
 
@@ -83005,7 +83148,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.156.0-82f95c630
+    // version: 1.157.0-612ff940a
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -83711,4 +83854,4 @@
     Object.defineProperty(exports, '__esModule', { value: true });
 
 }));
-// version: 1.156.0-edce97283
+// version: 1.157.0-4246d2656

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-worker-api",
-    "version": "1.156.0",
+    "version": "1.157.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "",
     "main": "dist/standalone/es/lds-worker-api.js",