@salesforce/lds-runtime-mobile 1.156.0 → 1.157.0

package/dist/main.js

@@ -31,6 +31,7 @@ import formattingOptions from 'lightning/i18nCldrOptions';
 import eagerEvalValidAt from '@salesforce/gate/lds.eagerEvalValidAt';
 import eagerEvalStaleWhileRevalidate from '@salesforce/gate/lds.eagerEvalStaleWhileRevalidate';
 import eagerEvalDefaultCachePolicy from '@salesforce/gate/lds.eagerEvalDefaultCachePolicy';
+import ldsPrimingGraphqlBatch from '@salesforce/gate/lds.primingGraphqlBatch';
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -4053,38 +4054,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;
@@ -4134,6 +4129,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) {
@@ -9044,7 +9053,7 @@ function dataTypeToType(objectInfoDataType, apiName) {
         case 'Url':
             return 'UrlValue';
         case 'Picklist':
-            return 'UrlValue';
+            return 'PicklistValue';
         case 'MultiPicklist':
             return 'MultiPicklistValue';
         case 'Percent':
@@ -15357,16 +15366,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) {
@@ -15401,91 +15413,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) => {
@@ -15538,12 +15588,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),
@@ -15555,11 +15632,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;
@@ -15574,6 +15651,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) => {
@@ -15697,7 +15783,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;
@@ -15709,7 +15844,7 @@ class NimbusPrimingNetworkAdapter {
             __nimbus.plugins.LdsNetworkAdapter
                 .sendRequest({
                 method: 'POST',
-                path: `/services/data/${apiVersion}/graphql`,
+                path: endPointPath,
                 body: JSON.stringify({
                     query,
                     variables,
@@ -15725,7 +15860,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();
@@ -15976,4 +16111,4 @@ register({
 });
 
 export { getRuntime, registerReportObserver, reportGraphqlQueryParseError };
-// version: 1.156.0-edce97283
+// version: 1.157.0-4246d2656

package/dist/types/priming/NimbusPrimingNetworkAdapter.d.ts

@@ -1,6 +1,7 @@
 import type { PrimingNetworkAdapter } from '@salesforce/lds-priming';
-import type { GraphQLRepresentation } from '@salesforce/lds-adapters-uiapi';
+import type { GraphQLRepresentation, GraphQLInputRepresentation } from '@salesforce/lds-adapters-uiapi';
 import type { LdsAbortController } from '@salesforce/lds-utils-adapters';
 export declare class NimbusPrimingNetworkAdapter implements PrimingNetworkAdapter {
+    postBatchGraphQL(configs: GraphQLInputRepresentation[], abortController: LdsAbortController): Promise<GraphQLRepresentation[]>;
     postGraphQL(query: string, variables: Record<string, any>, abortController: LdsAbortController): Promise<GraphQLRepresentation>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-mobile",
-    "version": "1.156.0",
+    "version": "1.157.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS runtime for mobile/hybrid environments.",
     "main": "dist/main.js",
@@ -58,7 +58,7 @@
             "path": "./dist/main.js",
             "maxSize": {
                 "none": "700 kB",
-                "min": "280 kB",
+                "min": "282 kB",
                 "compressed": "110 kB"
             }
         },
@@ -66,7 +66,7 @@
             "path": "./sfdc/main.js",
             "maxSize": {
                 "none": "700 kB",
-                "min": "280 kB",
+                "min": "282 kB",
                 "compressed": "110 kB"
             }
         }

package/sfdc/main.js

@@ -31,6 +31,7 @@ import formattingOptions from 'lightning/i18nCldrOptions';
 import eagerEvalValidAt from '@salesforce/gate/lds.eagerEvalValidAt';
 import eagerEvalStaleWhileRevalidate from '@salesforce/gate/lds.eagerEvalStaleWhileRevalidate';
 import eagerEvalDefaultCachePolicy from '@salesforce/gate/lds.eagerEvalDefaultCachePolicy';
+import ldsPrimingGraphqlBatch from '@salesforce/gate/lds.primingGraphqlBatch';
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -4053,38 +4054,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;
@@ -4134,6 +4129,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) {
@@ -9044,7 +9053,7 @@ function dataTypeToType(objectInfoDataType, apiName) {
         case 'Url':
             return 'UrlValue';
         case 'Picklist':
-            return 'UrlValue';
+            return 'PicklistValue';
         case 'MultiPicklist':
             return 'MultiPicklistValue';
         case 'Percent':
@@ -15357,16 +15366,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) {
@@ -15401,91 +15413,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) => {
@@ -15538,12 +15588,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),
@@ -15555,11 +15632,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;
@@ -15574,6 +15651,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) => {
@@ -15697,7 +15783,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;
@@ -15709,7 +15844,7 @@ class NimbusPrimingNetworkAdapter {
             __nimbus.plugins.LdsNetworkAdapter
                 .sendRequest({
                 method: 'POST',
-                path: `/services/data/${apiVersion}/graphql`,
+                path: endPointPath,
                 body: JSON.stringify({
                     query,
                     variables,
@@ -15725,7 +15860,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();
@@ -15976,4 +16111,4 @@ register({
 });
 
 export { getRuntime, registerReportObserver, reportGraphqlQueryParseError };
-// version: 1.156.0-edce97283
+// version: 1.157.0-4246d2656

package/sfdc/types/priming/NimbusPrimingNetworkAdapter.d.ts

@@ -1,6 +1,7 @@
 import type { PrimingNetworkAdapter } from '@salesforce/lds-priming';
-import type { GraphQLRepresentation } from '@salesforce/lds-adapters-uiapi';
+import type { GraphQLRepresentation, GraphQLInputRepresentation } from '@salesforce/lds-adapters-uiapi';
 import type { LdsAbortController } from '@salesforce/lds-utils-adapters';
 export declare class NimbusPrimingNetworkAdapter implements PrimingNetworkAdapter {
+    postBatchGraphQL(configs: GraphQLInputRepresentation[], abortController: LdsAbortController): Promise<GraphQLRepresentation[]>;
     postGraphQL(query: string, variables: Record<string, any>, abortController: LdsAbortController): Promise<GraphQLRepresentation>;
 }