@salesforce/lds-runtime-mobile 1.332.0-dev20 → 1.332.0-dev22

package/dist/main.js

@@ -52682,6 +52682,12 @@ function buildFieldUnionArray(existingRecord, incomingRecord, objectInfo) {
                 fieldUnion.push(`${fieldName}.Id`);
                 includesSpanningFields = true;
             }
+            else {
+                // Field exists on record but not in object info.
+                // Fall back to getRecords resolver in this case.
+                fieldUnion.push(fieldName);
+                includesSpanningFields = true;
+            }
         }
         else {
             fieldUnion.push(fieldName);
@@ -52909,6 +52915,7 @@ class ConflictPool {
 
 const DEFAULT_BATCH_SIZE = 500;
 const DEFAULT_CONCURRENCY = 6;
+const MAX_RETRY_COUNT = 2;
 class PrimingSession extends EventEmitter {
     constructor(config) {
         super();
@@ -52920,6 +52927,7 @@ class PrimingSession extends EventEmitter {
         this.ldsRecordRefresher = config.ldsRecordRefresher;
         this.networkWorkerPool = new AsyncWorkerPool(this.concurrency);
         this.conflictPool = new ConflictPool(config.store, this.objectInfoLoader);
+        this.retryTracker = new Map();
     }
     // function that enqueues priming work
     async enqueue(work) {
@@ -52938,6 +52946,9 @@ class PrimingSession extends EventEmitter {
             unavailableTypes,
         });
         if (unavailableIds.length > 0) {
+            for (const id of unavailableIds) {
+                this.retryTracker.delete(id);
+            }
             this.emit('error', {
                 ids: unavailableIds,
                 code: 'precondition-error',
@@ -52962,6 +52973,9 @@ class PrimingSession extends EventEmitter {
                         .fetchRecordData(batch, abortController)
                         .then(async (results) => {
                         if (abortController.aborted) {
+                            for (const id of batch.ids) {
+                                this.retryTracker.delete(id);
+                            }
                             return;
                         }
                         this.emit('batch-fetched', {
@@ -52998,6 +53012,9 @@ class PrimingSession extends EventEmitter {
                 code: primingError,
                 message: `${result.messages.join(',')}`,
             });
+            for (const id of result.missingIds) {
+                this.retryTracker.delete(id);
+            }
             return;
         }
         const { missingIds } = result;
@@ -53021,6 +53038,17 @@ class PrimingSession extends EventEmitter {
                 duration: Date.now() - beforeWrite,
             });
             if (abortController.aborted) {
+                for (const id of written) {
+                    this.retryTracker.delete(id);
+                }
+                for (const id of conflicted) {
+                    this.retryTracker.delete(id);
+                }
+                for (const error of errors) {
+                    for (const id of error.ids) {
+                        this.retryTracker.delete(id);
+                    }
+                }
                 return;
             }
             if (errors.length > 0) {
@@ -53030,11 +53058,17 @@ class PrimingSession extends EventEmitter {
                         code: 'unknown',
                         message: message,
                     });
+                    for (const id of ids) {
+                        this.retryTracker.delete(id);
+                    }
                 });
             }
             // now that the records are persisted, emit the primed event
             if (written.length > 0) {
                 this.emit('primed', Array.from(written));
+                for (const id of written) {
+                    this.retryTracker.delete(id);
+                }
             }
             // if any records could not be written to the store because there were conflicts, handle the conflicts
             if (conflicted.length > 0) {
@@ -53045,14 +53079,39 @@ class PrimingSession extends EventEmitter {
     async handleWriteConflicts(records, conflicted, abortController) {
         const result = await this.conflictPool.enqueueConflictedRecords(records.filter((x) => conflicted.includes(x.id)), abortController);
         if (abortController.aborted) {
+            for (const id of conflicted) {
+                this.retryTracker.delete(id);
+            }
             return;
         }
-        if (Object.keys(result.additionalWork.records).length > 0) {
+        if (keys$3(result.additionalWork.records).length > 0) {
             this.emit('conflict', {
                 ids: Object.values(result.additionalWork.records).flatMap((record) => record.ids),
                 resolution: 'priming-refresh',
             });
-            this.enqueue(result.additionalWork);
+            // we're re-enqueuing here, so apply retry limits which may change the batches
+            let limitedResult = this.applyRetryLimits(result.additionalWork);
+            this.enqueue(limitedResult.additionalWork);
+            if (limitedResult.recordsNeedingRefetch.size > 0) {
+                for (const key in keys$3(limitedResult.recordsNeedingRefetch)) {
+                    const value = limitedResult.recordsNeedingRefetch.get(key);
+                    if (result.recordsNeedingRefetch.has(key)) {
+                        let existing = result.recordsNeedingRefetch.get(key);
+                        existing = {
+                            // merge the ids
+                            ids: [...existing.ids, ...value.ids],
+                            // This is safe because they derive from the same
+                            // input, no chance of getting a new field in the
+                            // limited result
+                            fields: existing.fields,
+                        };
+                        result.recordsNeedingRefetch.set(key, existing);
+                    }
+                    else {
+                        result.recordsNeedingRefetch.set(key, value);
+                    }
+                }
+            }
         }
         if (result.resolvedRecords.length > 0) {
             this.emit('conflict', {
@@ -53060,8 +53119,14 @@ class PrimingSession extends EventEmitter {
                 resolution: 'priming-merge',
             });
             this.emit('primed', result.resolvedRecords);
+            for (const id of result.resolvedRecords) {
+                this.retryTracker.delete(id);
+            }
         }
         if (result.recordsToWrite.length > 0) {
+            for (const record of result.recordsToWrite) {
+                this.retryTracker.delete(record.id);
+            }
             const { written, errors, conflicted } = await this.recordIngestor.insertRecords(result.recordsToWrite, true);
             if (written.length > 0) {
                 const ids = Array.from(written);
@@ -53088,10 +53153,16 @@ class PrimingSession extends EventEmitter {
         if (result.recordsNeedingRefetch.size > 0) {
             const { loaded, errored } = await this.ldsRecordRefresher.loadRecords(result.recordsNeedingRefetch);
             if (loaded.length > 0) {
+                for (const id of loaded) {
+                    this.retryTracker.delete(id);
+                }
                 this.emit('conflict', { resolution: 'lds-refresh', ids: loaded });
                 this.emit('primed', loaded);
             }
             if (errored.length > 0) {
+                for (const id of errored) {
+                    this.retryTracker.delete(id);
+                }
                 this.emit('error', {
                     ids: errored,
                     code: 'unknown',
@@ -53100,6 +53171,50 @@ class PrimingSession extends EventEmitter {
             }
         }
     }
+    applyRetryLimits(primingWork) {
+        // retryable work goes back into priming session
+        let retryableWork = {
+            type: 'record-fields',
+            records: {},
+        };
+        // refetchable work gets delegated to getRecords
+        let refetchableWork = new Map();
+        for (const key of keys$3(primingWork.records)) {
+            let work = primingWork.records[key];
+            let limitedIds = [];
+            for (const id of work.ids) {
+                let retryCount = this.retryTracker.get(id) || 0;
+                retryCount += 1;
+                if (retryCount > MAX_RETRY_COUNT) {
+                    limitedIds.push(id);
+                    this.retryTracker.delete(id);
+                }
+                else {
+                    this.retryTracker.set(id, retryCount);
+                }
+            }
+            if (limitedIds.length < work.ids.length) {
+                retryableWork.records[key] = {
+                    ids: work.ids.filter((id) => limitedIds.indexOf(id) === -1),
+                    fields: work.fields,
+                };
+            }
+            if (limitedIds.length > 0) {
+                this.emit('retry-limit-reached', { ids: limitedIds });
+                refetchableWork.set(key, {
+                    ids: limitedIds,
+                    fields: work.fields,
+                });
+            }
+        }
+        return {
+            additionalWork: retryableWork,
+            recordsNeedingRefetch: refetchableWork,
+            resolvedRecords: [],
+            recordsToWrite: [],
+            errors: [],
+        };
+    }
     async fetchMetadata(batches) {
         const apiNames = Array.from(batches.reduce((acc, x) => {
             return acc.add(x.type);
@@ -53338,7 +53453,9 @@ class RecordLoaderGraphQL extends NetworkRecordLoader {
             return acc;
         }, {});
         fields['Id'] = { value: id, displayValue: null };
-        fields['RecordTypeId'] = { value: recordTypeId, displayValue: null };
+        if (objectInfo.fields['RecordTypeId'] !== undefined) {
+            fields['RecordTypeId'] = { value: recordTypeId, displayValue: null };
+        }
         let recordTypeInfo = null;
         if (recordTypeId !== null &&
             objectInfo.recordTypeInfos &&
@@ -55535,4 +55652,4 @@ register({
 });
 
 export { O11Y_NAMESPACE_LDS_MOBILE, getRuntime, registerReportObserver, reportGraphqlQueryParseError };
-// version: 1.332.0-dev20-f65bc51b43
+// version: 1.332.0-dev22-929db04706

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

@@ -4,7 +4,7 @@ import type { PrimingStore } from './PrimingStore';
 import type { PrimingWork } from './types';
 import type { ObjectInfoLoader } from './ObjectInfoLoader';
 type ConflictResolutionError = 'object-info-missing';
-interface ConflictResolutionResult {
+export interface ConflictResolutionResult {
     additionalWork: PrimingWork;
     recordsToWrite: DurableRecordRepresentation[];
     resolvedRecords: string[];

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

@@ -36,6 +36,9 @@ export interface PrimingEvents {
         errors: string[];
         duration: number;
     };
+    'retry-limit-reached': {
+        ids: string[];
+    };
 }
 interface EventErrorPayload {
     ids: string[];
@@ -56,12 +59,14 @@ export declare class PrimingSession extends EventEmitter<PrimingEvents> {
     private networkWorkerPool;
     private conflictPool;
     private ldsRecordRefresher;
+    private retryTracker;
     constructor(config: PrimingSessionConfig);
     enqueue(work: PrimingWork): Promise<void>;
     cancel(): void;
     private enqueueBatches;
     private processFetchedRecords;
     private handleWriteConflicts;
+    private applyRetryLimits;
     private fetchMetadata;
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-mobile",
-    "version": "1.332.0-dev20",
+    "version": "1.332.0-dev22",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS runtime for mobile/hybrid environments.",
     "main": "dist/main.js",
@@ -32,23 +32,23 @@
         "release:corejar": "yarn build && ../core-build/scripts/core.js --name=lds-runtime-mobile"
     },
     "dependencies": {
-        "@salesforce/lds-adapters-uiapi": "^1.332.0-dev20",
-        "@salesforce/lds-bindings": "^1.332.0-dev20",
-        "@salesforce/lds-instrumentation": "^1.332.0-dev20",
+        "@salesforce/lds-adapters-uiapi": "^1.332.0-dev22",
+        "@salesforce/lds-bindings": "^1.332.0-dev22",
+        "@salesforce/lds-instrumentation": "^1.332.0-dev22",
         "@salesforce/user": "0.0.21",
         "o11y": "250.7.0"
     },
     "devDependencies": {
-        "@salesforce/lds-adapters-graphql": "^1.332.0-dev20",
-        "@salesforce/lds-drafts": "^1.332.0-dev20",
-        "@salesforce/lds-durable-records": "^1.332.0-dev20",
-        "@salesforce/lds-network-adapter": "^1.332.0-dev20",
-        "@salesforce/lds-network-nimbus": "^1.332.0-dev20",
-        "@salesforce/lds-store-binary": "^1.332.0-dev20",
-        "@salesforce/lds-store-nimbus": "^1.332.0-dev20",
-        "@salesforce/lds-store-sql": "^1.332.0-dev20",
-        "@salesforce/lds-utils-adapters": "^1.332.0-dev20",
-        "@salesforce/nimbus-plugin-lds": "^1.332.0-dev20",
+        "@salesforce/lds-adapters-graphql": "^1.332.0-dev22",
+        "@salesforce/lds-drafts": "^1.332.0-dev22",
+        "@salesforce/lds-durable-records": "^1.332.0-dev22",
+        "@salesforce/lds-network-adapter": "^1.332.0-dev22",
+        "@salesforce/lds-network-nimbus": "^1.332.0-dev22",
+        "@salesforce/lds-store-binary": "^1.332.0-dev22",
+        "@salesforce/lds-store-nimbus": "^1.332.0-dev22",
+        "@salesforce/lds-store-sql": "^1.332.0-dev22",
+        "@salesforce/lds-utils-adapters": "^1.332.0-dev22",
+        "@salesforce/nimbus-plugin-lds": "^1.332.0-dev22",
         "babel-plugin-dynamic-import-node": "^2.3.3",
         "wait-for-expect": "^3.0.2"
     },

package/sfdc/main.js

@@ -52682,6 +52682,12 @@ function buildFieldUnionArray(existingRecord, incomingRecord, objectInfo) {
                 fieldUnion.push(`${fieldName}.Id`);
                 includesSpanningFields = true;
             }
+            else {
+                // Field exists on record but not in object info.
+                // Fall back to getRecords resolver in this case.
+                fieldUnion.push(fieldName);
+                includesSpanningFields = true;
+            }
         }
         else {
             fieldUnion.push(fieldName);
@@ -52909,6 +52915,7 @@ class ConflictPool {
 
 const DEFAULT_BATCH_SIZE = 500;
 const DEFAULT_CONCURRENCY = 6;
+const MAX_RETRY_COUNT = 2;
 class PrimingSession extends EventEmitter {
     constructor(config) {
         super();
@@ -52920,6 +52927,7 @@ class PrimingSession extends EventEmitter {
         this.ldsRecordRefresher = config.ldsRecordRefresher;
         this.networkWorkerPool = new AsyncWorkerPool(this.concurrency);
         this.conflictPool = new ConflictPool(config.store, this.objectInfoLoader);
+        this.retryTracker = new Map();
     }
     // function that enqueues priming work
     async enqueue(work) {
@@ -52938,6 +52946,9 @@ class PrimingSession extends EventEmitter {
             unavailableTypes,
         });
         if (unavailableIds.length > 0) {
+            for (const id of unavailableIds) {
+                this.retryTracker.delete(id);
+            }
             this.emit('error', {
                 ids: unavailableIds,
                 code: 'precondition-error',
@@ -52962,6 +52973,9 @@ class PrimingSession extends EventEmitter {
                         .fetchRecordData(batch, abortController)
                         .then(async (results) => {
                         if (abortController.aborted) {
+                            for (const id of batch.ids) {
+                                this.retryTracker.delete(id);
+                            }
                             return;
                         }
                         this.emit('batch-fetched', {
@@ -52998,6 +53012,9 @@ class PrimingSession extends EventEmitter {
                 code: primingError,
                 message: `${result.messages.join(',')}`,
             });
+            for (const id of result.missingIds) {
+                this.retryTracker.delete(id);
+            }
             return;
         }
         const { missingIds } = result;
@@ -53021,6 +53038,17 @@ class PrimingSession extends EventEmitter {
                 duration: Date.now() - beforeWrite,
             });
             if (abortController.aborted) {
+                for (const id of written) {
+                    this.retryTracker.delete(id);
+                }
+                for (const id of conflicted) {
+                    this.retryTracker.delete(id);
+                }
+                for (const error of errors) {
+                    for (const id of error.ids) {
+                        this.retryTracker.delete(id);
+                    }
+                }
                 return;
             }
             if (errors.length > 0) {
@@ -53030,11 +53058,17 @@ class PrimingSession extends EventEmitter {
                         code: 'unknown',
                         message: message,
                     });
+                    for (const id of ids) {
+                        this.retryTracker.delete(id);
+                    }
                 });
             }
             // now that the records are persisted, emit the primed event
             if (written.length > 0) {
                 this.emit('primed', Array.from(written));
+                for (const id of written) {
+                    this.retryTracker.delete(id);
+                }
             }
             // if any records could not be written to the store because there were conflicts, handle the conflicts
             if (conflicted.length > 0) {
@@ -53045,14 +53079,39 @@ class PrimingSession extends EventEmitter {
     async handleWriteConflicts(records, conflicted, abortController) {
         const result = await this.conflictPool.enqueueConflictedRecords(records.filter((x) => conflicted.includes(x.id)), abortController);
         if (abortController.aborted) {
+            for (const id of conflicted) {
+                this.retryTracker.delete(id);
+            }
             return;
         }
-        if (Object.keys(result.additionalWork.records).length > 0) {
+        if (keys$3(result.additionalWork.records).length > 0) {
             this.emit('conflict', {
                 ids: Object.values(result.additionalWork.records).flatMap((record) => record.ids),
                 resolution: 'priming-refresh',
             });
-            this.enqueue(result.additionalWork);
+            // we're re-enqueuing here, so apply retry limits which may change the batches
+            let limitedResult = this.applyRetryLimits(result.additionalWork);
+            this.enqueue(limitedResult.additionalWork);
+            if (limitedResult.recordsNeedingRefetch.size > 0) {
+                for (const key in keys$3(limitedResult.recordsNeedingRefetch)) {
+                    const value = limitedResult.recordsNeedingRefetch.get(key);
+                    if (result.recordsNeedingRefetch.has(key)) {
+                        let existing = result.recordsNeedingRefetch.get(key);
+                        existing = {
+                            // merge the ids
+                            ids: [...existing.ids, ...value.ids],
+                            // This is safe because they derive from the same
+                            // input, no chance of getting a new field in the
+                            // limited result
+                            fields: existing.fields,
+                        };
+                        result.recordsNeedingRefetch.set(key, existing);
+                    }
+                    else {
+                        result.recordsNeedingRefetch.set(key, value);
+                    }
+                }
+            }
         }
         if (result.resolvedRecords.length > 0) {
             this.emit('conflict', {
@@ -53060,8 +53119,14 @@ class PrimingSession extends EventEmitter {
                 resolution: 'priming-merge',
             });
             this.emit('primed', result.resolvedRecords);
+            for (const id of result.resolvedRecords) {
+                this.retryTracker.delete(id);
+            }
         }
         if (result.recordsToWrite.length > 0) {
+            for (const record of result.recordsToWrite) {
+                this.retryTracker.delete(record.id);
+            }
             const { written, errors, conflicted } = await this.recordIngestor.insertRecords(result.recordsToWrite, true);
             if (written.length > 0) {
                 const ids = Array.from(written);
@@ -53088,10 +53153,16 @@ class PrimingSession extends EventEmitter {
         if (result.recordsNeedingRefetch.size > 0) {
             const { loaded, errored } = await this.ldsRecordRefresher.loadRecords(result.recordsNeedingRefetch);
             if (loaded.length > 0) {
+                for (const id of loaded) {
+                    this.retryTracker.delete(id);
+                }
                 this.emit('conflict', { resolution: 'lds-refresh', ids: loaded });
                 this.emit('primed', loaded);
             }
             if (errored.length > 0) {
+                for (const id of errored) {
+                    this.retryTracker.delete(id);
+                }
                 this.emit('error', {
                     ids: errored,
                     code: 'unknown',
@@ -53100,6 +53171,50 @@ class PrimingSession extends EventEmitter {
             }
         }
     }
+    applyRetryLimits(primingWork) {
+        // retryable work goes back into priming session
+        let retryableWork = {
+            type: 'record-fields',
+            records: {},
+        };
+        // refetchable work gets delegated to getRecords
+        let refetchableWork = new Map();
+        for (const key of keys$3(primingWork.records)) {
+            let work = primingWork.records[key];
+            let limitedIds = [];
+            for (const id of work.ids) {
+                let retryCount = this.retryTracker.get(id) || 0;
+                retryCount += 1;
+                if (retryCount > MAX_RETRY_COUNT) {
+                    limitedIds.push(id);
+                    this.retryTracker.delete(id);
+                }
+                else {
+                    this.retryTracker.set(id, retryCount);
+                }
+            }
+            if (limitedIds.length < work.ids.length) {
+                retryableWork.records[key] = {
+                    ids: work.ids.filter((id) => limitedIds.indexOf(id) === -1),
+                    fields: work.fields,
+                };
+            }
+            if (limitedIds.length > 0) {
+                this.emit('retry-limit-reached', { ids: limitedIds });
+                refetchableWork.set(key, {
+                    ids: limitedIds,
+                    fields: work.fields,
+                });
+            }
+        }
+        return {
+            additionalWork: retryableWork,
+            recordsNeedingRefetch: refetchableWork,
+            resolvedRecords: [],
+            recordsToWrite: [],
+            errors: [],
+        };
+    }
     async fetchMetadata(batches) {
         const apiNames = Array.from(batches.reduce((acc, x) => {
             return acc.add(x.type);
@@ -53338,7 +53453,9 @@ class RecordLoaderGraphQL extends NetworkRecordLoader {
             return acc;
         }, {});
         fields['Id'] = { value: id, displayValue: null };
-        fields['RecordTypeId'] = { value: recordTypeId, displayValue: null };
+        if (objectInfo.fields['RecordTypeId'] !== undefined) {
+            fields['RecordTypeId'] = { value: recordTypeId, displayValue: null };
+        }
         let recordTypeInfo = null;
         if (recordTypeId !== null &&
             objectInfo.recordTypeInfos &&
@@ -55535,4 +55652,4 @@ register({
 });
 
 export { O11Y_NAMESPACE_LDS_MOBILE, getRuntime, registerReportObserver, reportGraphqlQueryParseError };
-// version: 1.332.0-dev20-f65bc51b43
+// version: 1.332.0-dev22-929db04706

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

@@ -4,7 +4,7 @@ import type { PrimingStore } from './PrimingStore';
 import type { PrimingWork } from './types';
 import type { ObjectInfoLoader } from './ObjectInfoLoader';
 type ConflictResolutionError = 'object-info-missing';
-interface ConflictResolutionResult {
+export interface ConflictResolutionResult {
     additionalWork: PrimingWork;
     recordsToWrite: DurableRecordRepresentation[];
     resolvedRecords: string[];

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

@@ -36,6 +36,9 @@ export interface PrimingEvents {
         errors: string[];
         duration: number;
     };
+    'retry-limit-reached': {
+        ids: string[];
+    };
 }
 interface EventErrorPayload {
     ids: string[];
@@ -56,12 +59,14 @@ export declare class PrimingSession extends EventEmitter<PrimingEvents> {
     private networkWorkerPool;
     private conflictPool;
     private ldsRecordRefresher;
+    private retryTracker;
     constructor(config: PrimingSessionConfig);
     enqueue(work: PrimingWork): Promise<void>;
     cancel(): void;
     private enqueueBatches;
     private processFetchedRecords;
     private handleWriteConflicts;
+    private applyRetryLimits;
     private fetchMetadata;
 }
 export {};