@salesforce/lds-runtime-mobile 1.208.0 → 1.209.0

package/dist/main.js

@@ -16,7 +16,7 @@ import { setupInstrumentation, instrumentAdapter as instrumentAdapter$1, instrum
 import { HttpStatusCode, StoreKeySet, serializeStructuredKey, Reader, deepFreeze, emitAdapterEvent, createCustomAdapterEventEmitter, StoreKeyMap, isFileReference, Environment, Luvio, InMemoryStore } from '@luvio/engine';
 import excludeStaleRecordsGate from '@salesforce/gate/lds.graphqlEvalExcludeStaleRecords';
 import { parseAndVisit, Kind, visit, execute, buildSchema, isObjectType, defaultFieldResolver } from '@luvio/graphql-parser';
-import { getRecordId18, keyBuilderQuickActionExecutionRepresentation, ingestQuickActionExecutionRepresentation, keyBuilderContentDocumentCompositeRepresentation, getResponseCacheKeysContentDocumentCompositeRepresentation, keyBuilderFromTypeContentDocumentCompositeRepresentation, ingestContentDocumentCompositeRepresentation, keyBuilderRecord, getTypeCacheKeysRecord, keyBuilderFromTypeRecordRepresentation, ingestRecord, RecordRepresentationRepresentationType, ObjectInfoRepresentationType, getRecordAdapterFactory, getObjectInfoAdapterFactory, getObjectInfosAdapterFactory, UiApiNamespace, RecordRepresentationType, RecordRepresentationTTL, RecordRepresentationVersion } from '@salesforce/lds-adapters-uiapi';
+import { getRecordId18, keyBuilderQuickActionExecutionRepresentation, ingestQuickActionExecutionRepresentation, keyBuilderContentDocumentCompositeRepresentation, getResponseCacheKeysContentDocumentCompositeRepresentation, keyBuilderFromTypeContentDocumentCompositeRepresentation, ingestContentDocumentCompositeRepresentation, keyBuilderRecord, getTypeCacheKeysRecord, keyBuilderFromTypeRecordRepresentation, ingestRecord, RecordRepresentationRepresentationType, ObjectInfoRepresentationType, getRecordAdapterFactory, getObjectInfoAdapterFactory, getObjectInfosAdapterFactory, UiApiNamespace, RecordRepresentationType, RecordRepresentationTTL, RecordRepresentationVersion, getRecordsAdapterFactory } from '@salesforce/lds-adapters-uiapi';
 import caseSensitiveUserId from '@salesforce/user/Id';
 import { idleDetector, getInstrumentation } from 'o11y/client';
 import ldsUseShortUrlGate from '@salesforce/gate/lds.useShortUrl';
@@ -14437,6 +14437,7 @@ const CREATE_CONTENT_DOCUMENT_AND_VERSION_DRAFT_SYNTHESIZE_ERROR = 'create-conte
 const PRIMING_TOTAL_SESSION_COUNT = 'priming-total-session-count';
 const PRIMING_TOTAL_ERROR_COUNT = 'priming-total-error-count';
 const PRIMING_TOTAL_PRIMED_COUNT = 'priming-total-primed-count';
+const PRIMING_TOTAL_CONFLICT_COUNT = 'priming-total-conflict-count';
 // logs
 const GRAPHQL_QUERY_PARSE_ERROR = 'gql-query-parse-error';
 const GRAPHQL_SQL_EVAL_PRECONDITION_ERROR = 'gql-sql-pre-eval-error';
@@ -14548,6 +14549,11 @@ function reportPrimingError(errorType, recordCount) {
 function reportPrimingSuccess(recordCount) {
     ldsMobileInstrumentation.incrementCounter(PRIMING_TOTAL_PRIMED_COUNT, recordCount, undefined);
 }
+function reportPrimingConflict(resolutionType, recordCount) {
+    ldsMobileInstrumentation.incrementCounter(PRIMING_TOTAL_CONFLICT_COUNT, recordCount, undefined, {
+        resolutionType,
+    });
+}
 
 /**
  * HOF (high-order-function) that instruments any async operation.  If the operation
@@ -15549,6 +15555,245 @@ function generateTypedBatches(work, batchSize) {
     return batches;
 }
 
+function getMissingElementsFromSuperset(superset, subset) {
+    return subset.filter((val) => !superset.includes(val));
+}
+function findReferenceFieldForSpanningField(fieldName, objectInfo) {
+    const fieldNames = Object.keys(objectInfo.fields);
+    for (const objectInfoFieldName of fieldNames) {
+        const field = objectInfo.fields[objectInfoFieldName];
+        if (field.reference === true && field.relationshipName === fieldName) {
+            return objectInfoFieldName;
+        }
+    }
+}
+function buildFieldUnionArray(existingRecord, incomingRecord, objectInfo) {
+    const allFields = Array.from(new Set([...Object.keys(existingRecord.fields), ...Object.keys(incomingRecord.fields)]));
+    const fieldUnion = [];
+    allFields.forEach((fieldName) => {
+        const objectInfoField = objectInfo.fields[fieldName];
+        if (objectInfoField === undefined) {
+            // find the reference field for the spanning field
+            const referenceField = findReferenceFieldForSpanningField(fieldName, objectInfo);
+            if (referenceField !== undefined) {
+                fieldUnion.push(`${fieldName}.Id`);
+            }
+        }
+        else {
+            fieldUnion.push(fieldName);
+        }
+    });
+    return fieldUnion;
+}
+/**
+ * Merges (if possible) an incoming record from a priming session with an existing record in the durable store.
+ *
+ * IMPORTANT NOTE: this is not a suitable function to use for general merging of two DurableRecordRepresentation since it
+ * makes the assumption that the incoming record ONLY contains scalar field values and no spanning records. The same is not
+ * necessarily true for the existing record as it may have been populated in the cache outside of a priming session.
+ * This function should not be moved out of the priming module!
+ *
+ * @param existingRecord Existing record in the durable store
+ * @param incomingRecord Incoming record from the priming session
+ * @param objectInfo Object info for the incoming record type
+ * @returns Merge result describing the success or failure of the merge operation
+ */
+function mergeRecord(existingRecord, incomingRecord, objectInfo) {
+    // cache already contains everything incoming has
+    if (existingRecord.weakEtag >= incomingRecord.weakEtag &&
+        getMissingElementsFromSuperset(Object.keys(existingRecord.fields), Object.keys(incomingRecord.fields)).length === 0) {
+        return {
+            ok: true,
+            code: 'success',
+            needsWrite: false,
+            record: existingRecord,
+        };
+    }
+    // don't touch records that contain drafts
+    if (existingRecord.drafts !== undefined) {
+        return {
+            ok: false,
+            code: 'conflict-drafts',
+            hasDraft: true,
+            fieldUnion: buildFieldUnionArray(existingRecord, incomingRecord, objectInfo),
+        };
+    }
+    // Check if incoming record's Etag is equal to the existing one
+    if (existingRecord.weakEtag === incomingRecord.weakEtag) {
+        // If so, merge the fields and return the updated record
+        return {
+            ok: true,
+            needsWrite: true,
+            code: 'success',
+            record: {
+                ...existingRecord,
+                fields: {
+                    ...existingRecord.fields,
+                    ...incomingRecord.fields,
+                },
+                links: {
+                    ...existingRecord.links,
+                    ...incomingRecord.links,
+                },
+            },
+        };
+    }
+    else if (incomingRecord.weakEtag > existingRecord.weakEtag &&
+        getMissingElementsFromSuperset(Object.keys(incomingRecord.fields), Object.keys(existingRecord.fields)).length === 0) {
+        // If incoming record's Etag is higher and contains all the fields, overwrite the record
+        // NOTE: if existing record contains spanning records, this condition will never hit since incoming won't have those fields
+        return { ok: true, code: 'success', needsWrite: true, record: incomingRecord };
+    }
+    else {
+        const missingFields = getMissingElementsFromSuperset(Object.keys(incomingRecord.fields), Object.keys(existingRecord.fields));
+        // if the only missing fields are spanning fields and their corresponding lookup fields match, we can merge
+        // since none of the changed fields are part of the incoming record
+        if (missingFields.every((field) => {
+            const referenceFieldName = findReferenceFieldForSpanningField(field, objectInfo);
+            if (referenceFieldName !== undefined) {
+                return (incomingRecord.fields[referenceFieldName].value ===
+                    existingRecord.fields[referenceFieldName].value);
+            }
+            else {
+                return false;
+            }
+        })) {
+            return {
+                ok: true,
+                needsWrite: true,
+                code: 'success',
+                record: {
+                    // we span the existing record to maintain spanning references
+                    ...incomingRecord,
+                    fields: {
+                        ...existingRecord.fields,
+                        ...incomingRecord.fields,
+                    },
+                    links: {
+                        ...existingRecord.links,
+                        ...incomingRecord.links,
+                    },
+                },
+            };
+        }
+        // If Etags do not match and the incoming record does not contain all fields, re-request the record
+        return {
+            ok: false,
+            code: 'conflict-missing-fields',
+            fieldUnion: buildFieldUnionArray(existingRecord, incomingRecord, objectInfo),
+            hasDraft: false,
+        };
+    }
+}
+
+const CONFLICT_POOL_SIZE = 5;
+/**
+ * A pool of workers that resolve conflicts between incoming records and records in the store.
+ */
+class ConflictPool {
+    constructor(store, objectInfoLoader) {
+        this.store = store;
+        this.objectInfoLoader = objectInfoLoader;
+        this.pool = new AsyncWorkerPool(CONFLICT_POOL_SIZE);
+    }
+    enqueueConflictedRecords(records, abortController) {
+        return this.pool.push({
+            workFn: () => this.resolveConflicts(records, abortController),
+        });
+    }
+    async resolveConflicts(incomingRecords, abortController) {
+        const result = {
+            additionalWork: { type: 'record-fields', records: {} },
+            recordsToWrite: [],
+            resolvedRecords: [],
+            recordsNeedingRefetch: new Map(),
+            errors: [],
+        };
+        const ids = [];
+        const trackedFieldsByType = new Map();
+        const apiNames = new Set();
+        incomingRecords.forEach((record) => {
+            ids.push(record.id);
+            apiNames.add(record.apiName);
+        });
+        const existingRecords = await this.store.readRecords(ids);
+        if (abortController.aborted) {
+            return result;
+        }
+        const objectInfos = await this.objectInfoLoader.getObjectInfos(Array.from(apiNames));
+        if (abortController.aborted) {
+            return result;
+        }
+        const existingRecordsById = new Map(existingRecords.map((record) => [record.record.id, record]));
+        for (const incomingRecord of incomingRecords) {
+            const existingDurableRecordRepresentation = existingRecordsById.get(incomingRecord.id);
+            const objectInfo = objectInfos[incomingRecord.apiName];
+            if (existingDurableRecordRepresentation === undefined) {
+                // this shouldn't happen but if it does, we should write the incoming record since there's nothing to merge
+                result.recordsToWrite.push(incomingRecord);
+                continue;
+            }
+            if (objectInfo === undefined) {
+                // object infos are a prerequisite for priming so if we don't have one, we can't do anything
+                result.errors.push({ id: incomingRecord.id, reason: 'object-info-missing' });
+                continue;
+            }
+            const existingRecord = existingDurableRecordRepresentation.record;
+            const mergedRecordResult = mergeRecord(existingRecord, incomingRecord, objectInfo);
+            if (mergedRecordResult.ok) {
+                if (mergedRecordResult.needsWrite) {
+                    result.recordsToWrite.push(mergedRecordResult.record);
+                }
+                else {
+                    result.resolvedRecords.push(mergedRecordResult.record.id);
+                }
+                continue;
+            }
+            else {
+                const { code } = mergedRecordResult;
+                const isConflict = code === 'conflict-drafts' ||
+                    code === 'conflict-spanning-record' ||
+                    code === 'conflict-missing-fields';
+                if (isConflict) {
+                    let trackedFields = trackedFieldsByType.get(incomingRecord.apiName);
+                    if (trackedFields === undefined) {
+                        trackedFields = new Set();
+                        trackedFieldsByType.set(incomingRecord.apiName, trackedFields);
+                    }
+                    mergedRecordResult.fieldUnion.forEach((field) => trackedFields.add(field));
+                    if (code === 'conflict-missing-fields') {
+                        const additionalWorkForType = result.additionalWork.records[incomingRecord.apiName];
+                        if (additionalWorkForType === undefined) {
+                            result.additionalWork.records[incomingRecord.apiName] = {
+                                ids: [incomingRecord.id],
+                                fields: Array.from(trackedFields),
+                            };
+                        }
+                        else {
+                            additionalWorkForType.ids.push(incomingRecord.id);
+                            additionalWorkForType.fields = Array.from(trackedFields);
+                        }
+                    }
+                    else if (code === 'conflict-drafts' || code === 'conflict-spanning-record') {
+                        const recordByType = result.recordsNeedingRefetch.get(incomingRecord.apiName);
+                        if (recordByType === undefined) {
+                            result.recordsNeedingRefetch.set(incomingRecord.apiName, {
+                                ids: [incomingRecord.id],
+                                fields: Array.from(trackedFields),
+                            });
+                        }
+                        else {
+                            recordByType.ids.push(incomingRecord.id);
+                            recordByType.fields = Array.from(trackedFields);
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+}
+
 const DEFAULT_BATCH_SIZE = 500;
 const DEFAULT_CONCURRENCY = 6;
 const DEFAULT_GQL_QUERY_BATCH_SIZE = 5;
@@ -15562,8 +15807,10 @@ class PrimingSession extends EventEmitter {
         this.recordLoader = config.recordLoader;
         this.recordIngestor = config.recordIngestor;
         this.objectInfoLoader = config.objectInfoLoader;
+        this.ldsRecordRefresher = config.ldsRecordRefresher;
         this.networkWorkerPool = new AsyncWorkerPool(this.concurrency);
         this.useBatchGQL = ldsPrimingGraphqlBatch.isOpen({ fallback: false });
+        this.conflictPool = new ConflictPool(config.store, this.objectInfoLoader);
     }
     // function that enqueues priming work
     async enqueue(work) {
@@ -15688,7 +15935,9 @@ class PrimingSession extends EventEmitter {
         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.recordIngestor
+            .insertRecords(records, false)
+            .then(({ written, conflicted, errors }) => {
             this.emit('batch-written', {
                 written,
                 conflicted,
@@ -15711,16 +15960,69 @@ class PrimingSession extends EventEmitter {
             if (written.length > 0) {
                 this.emit('primed', Array.from(written));
             }
-            // TODO [W-12436213]: implement conflict resolution
+            // if any records could not be written to the store because there were conflicts, handle the conflicts
+            if (conflicted.length > 0) {
+                this.handleWriteConflicts(records, conflicted, abortController);
+            }
+        });
+    }
+    async handleWriteConflicts(records, conflicted, abortController) {
+        const result = await this.conflictPool.enqueueConflictedRecords(records.filter((x) => conflicted.includes(x.id)), abortController);
+        if (abortController.aborted) {
+            return;
+        }
+        if (Object.keys(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);
+        }
+        if (result.resolvedRecords.length > 0) {
+            this.emit('conflict', {
+                ids: result.resolvedRecords,
+                resolution: 'priming-merge',
+            });
+            this.emit('primed', result.resolvedRecords);
+        }
+        if (result.recordsToWrite.length > 0) {
+            const { written, errors, conflicted } = await this.recordIngestor.insertRecords(result.recordsToWrite, true);
+            if (written.length > 0) {
+                const ids = Array.from(written);
+                this.emit('conflict', { ids, resolution: 'priming-merge' });
+                this.emit('primed', ids);
+            }
+            if (errors.length > 0) {
+                errors.forEach(({ ids, message }) => {
+                    this.emit('error', {
+                        ids,
+                        code: 'unknown',
+                        message: message,
+                    });
+                });
+            }
             if (conflicted.length > 0) {
-                // for now emit conlicts as errors
                 this.emit('error', {
-                    ids: Array.from(conflicted),
+                    ids: conflicted,
                     code: 'unknown',
-                    message: 'conflict when persisting record',
+                    message: 'unexpected write conflict',
                 });
             }
-        });
+        }
+        if (result.recordsNeedingRefetch.size > 0) {
+            const { loaded, errored } = await this.ldsRecordRefresher.loadRecords(result.recordsNeedingRefetch);
+            if (loaded.length > 0) {
+                this.emit('conflict', { resolution: 'lds-refresh', ids: loaded });
+                this.emit('primed', loaded);
+            }
+            if (errored.length > 0) {
+                this.emit('error', {
+                    ids: errored,
+                    code: 'unknown',
+                    message: `could not resolve conflicts`,
+                });
+            }
+        }
     }
     async fetchMetadata(batches) {
         const apiNames = Array.from(batches.reduce((acc, x) => {
@@ -15961,6 +16263,9 @@ function instrumentPrimingSession(session) {
     session.on('primed', ({ length }) => {
         reportPrimingSuccess(length);
     });
+    session.on('conflict', ({ ids, resolution }) => {
+        reportPrimingConflict(resolution, ids.length);
+    });
     return session;
 }
 
@@ -16142,19 +16447,72 @@ function batchArray(arr, batchSize = BATCH_SIZE) {
     return batches;
 }
 
+/**
+ * A polyfill for Promise.allSettled
+ * @param promises An array of promises
+ * @returns the result of all the promises when they either fulfill or reject
+ */
+function allSettled(promises) {
+    let wrappedPromises = promises.map((p) => Promise.resolve(p).then((value) => ({ status: 'fulfilled', value }), (reason) => ({ status: 'rejected', reason })));
+    return Promise.all(wrappedPromises);
+}
+
+class LdsPrimingRecordRefresher {
+    constructor(getRecordsAdapter) {
+        this.getRecordsAdapter = getRecordsAdapter;
+    }
+    async loadRecords(records) {
+        const requestedRecords = new Set();
+        const promises = Array.from(records).flatMap(([_apiName, value]) => {
+            value.ids.forEach((id) => requestedRecords.add(id));
+            return Promise.resolve(this.getRecordsAdapter({
+                records: [
+                    {
+                        recordIds: value.ids,
+                        optionalFields: value.fields.map((f) => `${_apiName}.${f}`),
+                    },
+                ],
+            }));
+        });
+        const promiseResults = await allSettled(promises);
+        const loaded = [];
+        promiseResults.forEach((promiseResult) => {
+            if (promiseResult.status === 'fulfilled') {
+                const batchResultRepresenatation = promiseResult.value;
+                if (batchResultRepresenatation &&
+                    batchResultRepresenatation.state === 'Fulfilled') {
+                    batchResultRepresenatation.data.results.forEach((result) => {
+                        if (result.statusCode === 200) {
+                            const id = result.result.id;
+                            loaded.push(id);
+                            requestedRecords.delete(id);
+                        }
+                    });
+                }
+            }
+        });
+        // errored contains all the requestedRecords that weren't loaded
+        const errored = Array.from(requestedRecords);
+        return { loaded, errored };
+    }
+}
+
 function primingSessionFactory(config) {
     const { store, objectInfoService, getLuvio } = config;
     const networkAdapter = new NimbusPrimingNetworkAdapter();
     const recordLoader = new RecordLoaderGraphQL(networkAdapter);
-    const recordIngestor = new RecordIngestor(new SqlitePrimingStore(getLuvio, store), getLuvio);
+    const primingStore = new SqlitePrimingStore(getLuvio, store);
+    const recordIngestor = new RecordIngestor(primingStore, getLuvio);
     const session = new PrimingSession({
         recordLoader,
         recordIngestor,
+        store: primingStore,
         objectInfoLoader: {
             getObjectInfos: objectInfoService.getObjectInfos.bind(objectInfoService),
         },
         concurrency: config.concurrency,
         batchSize: config.batchSize,
+        ldsRecordRefresher: new LdsPrimingRecordRefresher(config.getRecords),
     });
     return instrumentPrimingSession(session);
 }
@@ -16168,6 +16526,7 @@ let lazyEnvironment;
 let lazyBaseDurableStore;
 let lazyNetworkAdapter;
 let lazyObjectInfoService;
+let lazyGetRecords;
 /**
  * This returns the LDS on Mobile Runtime singleton object.
  */
@@ -16238,6 +16597,7 @@ function getRuntime() {
         lazyLuvio = new Luvio(lazyEnvironment, {
             instrument: instrumentLuvio,
         });
+        lazyGetRecords = getRecordsAdapterFactory(lazyLuvio);
         // Currently instruments store runtime perf
         setupMobileInstrumentation(lazyLuvio, store);
         // If the inspection nimbus plugin is configured, inspection is enabled otherwise this is a no-op
@@ -16292,6 +16652,7 @@ function getRuntime() {
                 getLuvio: () => lazyLuvio,
                 concurrency: config.concurrency,
                 batchSize: config.batchSize,
+                getRecords: lazyGetRecords,
             });
         },
     };
@@ -16310,4 +16671,4 @@ register({
 });
 
 export { getRuntime, registerReportObserver, reportGraphqlQueryParseError };
-// version: 1.208.0-75bd0667c
+// version: 1.209.0-6b633d53a

package/dist/types/instrumentation/metrics.d.ts

@@ -14,3 +14,4 @@ export declare function reportDraftAwareContentVersionSynthesizeCalls(mimeType:
 export declare function reportPrimingSessionCreated(): void;
 export declare function reportPrimingError(errorType: string, recordCount: number): void;
 export declare function reportPrimingSuccess(recordCount: number): void;
+export declare function reportPrimingConflict(resolutionType: string, recordCount: number): void;

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

@@ -1,12 +1,14 @@
 import { PrimingSession } from '@salesforce/lds-priming';
-import type { Luvio } from '@luvio/engine';
+import type { Adapter, Luvio } from '@luvio/engine';
 import type { NimbusSqliteStore } from '@salesforce/lds-store-nimbus';
 import type { ObjectInfoService } from '../main';
+import type { BatchRepresentation, GetRecordsConfig } from '@salesforce/lds-adapters-uiapi';
 export interface PrimingSessionFactoryConfig {
     store: NimbusSqliteStore;
     objectInfoService: ObjectInfoService;
     getLuvio: () => Luvio;
     concurrency?: number;
     batchSize?: number;
+    getRecords: Adapter<GetRecordsConfig, BatchRepresentation>;
 }
 export declare function primingSessionFactory(config: PrimingSessionFactoryConfig): PrimingSession;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-runtime-mobile",
-    "version": "1.208.0",
+    "version": "1.209.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS runtime for mobile/hybrid environments.",
     "main": "dist/main.js",
@@ -58,17 +58,17 @@
         {
             "path": "./dist/main.js",
             "maxSize": {
-                "none": "700 kB",
+                "none": "800 kB",
                 "min": "300 kB",
-                "compressed": "110 kB"
+                "compressed": "150 kB"
             }
         },
         {
             "path": "./sfdc/main.js",
             "maxSize": {
-                "none": "700 kB",
+                "none": "800 kB",
                 "min": "300 kB",
-                "compressed": "110 kB"
+                "compressed": "150 kB"
             }
         }
     ],

package/sfdc/main.js

@@ -16,7 +16,7 @@ import { setupInstrumentation, instrumentAdapter as instrumentAdapter$1, instrum
 import { HttpStatusCode, StoreKeySet, serializeStructuredKey, Reader, deepFreeze, emitAdapterEvent, createCustomAdapterEventEmitter, StoreKeyMap, isFileReference, Environment, Luvio, InMemoryStore } from 'force/luvioEngine';
 import excludeStaleRecordsGate from '@salesforce/gate/lds.graphqlEvalExcludeStaleRecords';
 import { parseAndVisit, Kind, visit, execute, buildSchema, isObjectType, defaultFieldResolver } from 'force/ldsGraphqlParser';
-import { getRecordId18, keyBuilderQuickActionExecutionRepresentation, ingestQuickActionExecutionRepresentation, keyBuilderContentDocumentCompositeRepresentation, getResponseCacheKeysContentDocumentCompositeRepresentation, keyBuilderFromTypeContentDocumentCompositeRepresentation, ingestContentDocumentCompositeRepresentation, keyBuilderRecord, getTypeCacheKeysRecord, keyBuilderFromTypeRecordRepresentation, ingestRecord, RecordRepresentationRepresentationType, ObjectInfoRepresentationType, getRecordAdapterFactory, getObjectInfoAdapterFactory, getObjectInfosAdapterFactory, UiApiNamespace, RecordRepresentationType, RecordRepresentationTTL, RecordRepresentationVersion } from 'force/ldsAdaptersUiapi';
+import { getRecordId18, keyBuilderQuickActionExecutionRepresentation, ingestQuickActionExecutionRepresentation, keyBuilderContentDocumentCompositeRepresentation, getResponseCacheKeysContentDocumentCompositeRepresentation, keyBuilderFromTypeContentDocumentCompositeRepresentation, ingestContentDocumentCompositeRepresentation, keyBuilderRecord, getTypeCacheKeysRecord, keyBuilderFromTypeRecordRepresentation, ingestRecord, RecordRepresentationRepresentationType, ObjectInfoRepresentationType, getRecordAdapterFactory, getObjectInfoAdapterFactory, getObjectInfosAdapterFactory, UiApiNamespace, RecordRepresentationType, RecordRepresentationTTL, RecordRepresentationVersion, getRecordsAdapterFactory } from 'force/ldsAdaptersUiapi';
 import caseSensitiveUserId from '@salesforce/user/Id';
 import { idleDetector, getInstrumentation } from 'o11y/client';
 import ldsUseShortUrlGate from '@salesforce/gate/lds.useShortUrl';
@@ -14437,6 +14437,7 @@ const CREATE_CONTENT_DOCUMENT_AND_VERSION_DRAFT_SYNTHESIZE_ERROR = 'create-conte
 const PRIMING_TOTAL_SESSION_COUNT = 'priming-total-session-count';
 const PRIMING_TOTAL_ERROR_COUNT = 'priming-total-error-count';
 const PRIMING_TOTAL_PRIMED_COUNT = 'priming-total-primed-count';
+const PRIMING_TOTAL_CONFLICT_COUNT = 'priming-total-conflict-count';
 // logs
 const GRAPHQL_QUERY_PARSE_ERROR = 'gql-query-parse-error';
 const GRAPHQL_SQL_EVAL_PRECONDITION_ERROR = 'gql-sql-pre-eval-error';
@@ -14548,6 +14549,11 @@ function reportPrimingError(errorType, recordCount) {
 function reportPrimingSuccess(recordCount) {
     ldsMobileInstrumentation.incrementCounter(PRIMING_TOTAL_PRIMED_COUNT, recordCount, undefined);
 }
+function reportPrimingConflict(resolutionType, recordCount) {
+    ldsMobileInstrumentation.incrementCounter(PRIMING_TOTAL_CONFLICT_COUNT, recordCount, undefined, {
+        resolutionType,
+    });
+}
 
 /**
  * HOF (high-order-function) that instruments any async operation.  If the operation
@@ -15549,6 +15555,245 @@ function generateTypedBatches(work, batchSize) {
     return batches;
 }
 
+function getMissingElementsFromSuperset(superset, subset) {
+    return subset.filter((val) => !superset.includes(val));
+}
+function findReferenceFieldForSpanningField(fieldName, objectInfo) {
+    const fieldNames = Object.keys(objectInfo.fields);
+    for (const objectInfoFieldName of fieldNames) {
+        const field = objectInfo.fields[objectInfoFieldName];
+        if (field.reference === true && field.relationshipName === fieldName) {
+            return objectInfoFieldName;
+        }
+    }
+}
+function buildFieldUnionArray(existingRecord, incomingRecord, objectInfo) {
+    const allFields = Array.from(new Set([...Object.keys(existingRecord.fields), ...Object.keys(incomingRecord.fields)]));
+    const fieldUnion = [];
+    allFields.forEach((fieldName) => {
+        const objectInfoField = objectInfo.fields[fieldName];
+        if (objectInfoField === undefined) {
+            // find the reference field for the spanning field
+            const referenceField = findReferenceFieldForSpanningField(fieldName, objectInfo);
+            if (referenceField !== undefined) {
+                fieldUnion.push(`${fieldName}.Id`);
+            }
+        }
+        else {
+            fieldUnion.push(fieldName);
+        }
+    });
+    return fieldUnion;
+}
+/**
+ * Merges (if possible) an incoming record from a priming session with an existing record in the durable store.
+ *
+ * IMPORTANT NOTE: this is not a suitable function to use for general merging of two DurableRecordRepresentation since it
+ * makes the assumption that the incoming record ONLY contains scalar field values and no spanning records. The same is not
+ * necessarily true for the existing record as it may have been populated in the cache outside of a priming session.
+ * This function should not be moved out of the priming module!
+ *
+ * @param existingRecord Existing record in the durable store
+ * @param incomingRecord Incoming record from the priming session
+ * @param objectInfo Object info for the incoming record type
+ * @returns Merge result describing the success or failure of the merge operation
+ */
+function mergeRecord(existingRecord, incomingRecord, objectInfo) {
+    // cache already contains everything incoming has
+    if (existingRecord.weakEtag >= incomingRecord.weakEtag &&
+        getMissingElementsFromSuperset(Object.keys(existingRecord.fields), Object.keys(incomingRecord.fields)).length === 0) {
+        return {
+            ok: true,
+            code: 'success',
+            needsWrite: false,
+            record: existingRecord,
+        };
+    }
+    // don't touch records that contain drafts
+    if (existingRecord.drafts !== undefined) {
+        return {
+            ok: false,
+            code: 'conflict-drafts',
+            hasDraft: true,
+            fieldUnion: buildFieldUnionArray(existingRecord, incomingRecord, objectInfo),
+        };
+    }
+    // Check if incoming record's Etag is equal to the existing one
+    if (existingRecord.weakEtag === incomingRecord.weakEtag) {
+        // If so, merge the fields and return the updated record
+        return {
+            ok: true,
+            needsWrite: true,
+            code: 'success',
+            record: {
+                ...existingRecord,
+                fields: {
+                    ...existingRecord.fields,
+                    ...incomingRecord.fields,
+                },
+                links: {
+                    ...existingRecord.links,
+                    ...incomingRecord.links,
+                },
+            },
+        };
+    }
+    else if (incomingRecord.weakEtag > existingRecord.weakEtag &&
+        getMissingElementsFromSuperset(Object.keys(incomingRecord.fields), Object.keys(existingRecord.fields)).length === 0) {
+        // If incoming record's Etag is higher and contains all the fields, overwrite the record
+        // NOTE: if existing record contains spanning records, this condition will never hit since incoming won't have those fields
+        return { ok: true, code: 'success', needsWrite: true, record: incomingRecord };
+    }
+    else {
+        const missingFields = getMissingElementsFromSuperset(Object.keys(incomingRecord.fields), Object.keys(existingRecord.fields));
+        // if the only missing fields are spanning fields and their corresponding lookup fields match, we can merge
+        // since none of the changed fields are part of the incoming record
+        if (missingFields.every((field) => {
+            const referenceFieldName = findReferenceFieldForSpanningField(field, objectInfo);
+            if (referenceFieldName !== undefined) {
+                return (incomingRecord.fields[referenceFieldName].value ===
+                    existingRecord.fields[referenceFieldName].value);
+            }
+            else {
+                return false;
+            }
+        })) {
+            return {
+                ok: true,
+                needsWrite: true,
+                code: 'success',
+                record: {
+                    // we span the existing record to maintain spanning references
+                    ...incomingRecord,
+                    fields: {
+                        ...existingRecord.fields,
+                        ...incomingRecord.fields,
+                    },
+                    links: {
+                        ...existingRecord.links,
+                        ...incomingRecord.links,
+                    },
+                },
+            };
+        }
+        // If Etags do not match and the incoming record does not contain all fields, re-request the record
+        return {
+            ok: false,
+            code: 'conflict-missing-fields',
+            fieldUnion: buildFieldUnionArray(existingRecord, incomingRecord, objectInfo),
+            hasDraft: false,
+        };
+    }
+}
+
+const CONFLICT_POOL_SIZE = 5;
+/**
+ * A pool of workers that resolve conflicts between incoming records and records in the store.
+ */
+class ConflictPool {
+    constructor(store, objectInfoLoader) {
+        this.store = store;
+        this.objectInfoLoader = objectInfoLoader;
+        this.pool = new AsyncWorkerPool(CONFLICT_POOL_SIZE);
+    }
+    enqueueConflictedRecords(records, abortController) {
+        return this.pool.push({
+            workFn: () => this.resolveConflicts(records, abortController),
+        });
+    }
+    async resolveConflicts(incomingRecords, abortController) {
+        const result = {
+            additionalWork: { type: 'record-fields', records: {} },
+            recordsToWrite: [],
+            resolvedRecords: [],
+            recordsNeedingRefetch: new Map(),
+            errors: [],
+        };
+        const ids = [];
+        const trackedFieldsByType = new Map();
+        const apiNames = new Set();
+        incomingRecords.forEach((record) => {
+            ids.push(record.id);
+            apiNames.add(record.apiName);
+        });
+        const existingRecords = await this.store.readRecords(ids);
+        if (abortController.aborted) {
+            return result;
+        }
+        const objectInfos = await this.objectInfoLoader.getObjectInfos(Array.from(apiNames));
+        if (abortController.aborted) {
+            return result;
+        }
+        const existingRecordsById = new Map(existingRecords.map((record) => [record.record.id, record]));
+        for (const incomingRecord of incomingRecords) {
+            const existingDurableRecordRepresentation = existingRecordsById.get(incomingRecord.id);
+            const objectInfo = objectInfos[incomingRecord.apiName];
+            if (existingDurableRecordRepresentation === undefined) {
+                // this shouldn't happen but if it does, we should write the incoming record since there's nothing to merge
+                result.recordsToWrite.push(incomingRecord);
+                continue;
+            }
+            if (objectInfo === undefined) {
+                // object infos are a prerequisite for priming so if we don't have one, we can't do anything
+                result.errors.push({ id: incomingRecord.id, reason: 'object-info-missing' });
+                continue;
+            }
+            const existingRecord = existingDurableRecordRepresentation.record;
+            const mergedRecordResult = mergeRecord(existingRecord, incomingRecord, objectInfo);
+            if (mergedRecordResult.ok) {
+                if (mergedRecordResult.needsWrite) {
+                    result.recordsToWrite.push(mergedRecordResult.record);
+                }
+                else {
+                    result.resolvedRecords.push(mergedRecordResult.record.id);
+                }
+                continue;
+            }
+            else {
+                const { code } = mergedRecordResult;
+                const isConflict = code === 'conflict-drafts' ||
+                    code === 'conflict-spanning-record' ||
+                    code === 'conflict-missing-fields';
+                if (isConflict) {
+                    let trackedFields = trackedFieldsByType.get(incomingRecord.apiName);
+                    if (trackedFields === undefined) {
+                        trackedFields = new Set();
+                        trackedFieldsByType.set(incomingRecord.apiName, trackedFields);
+                    }
+                    mergedRecordResult.fieldUnion.forEach((field) => trackedFields.add(field));
+                    if (code === 'conflict-missing-fields') {
+                        const additionalWorkForType = result.additionalWork.records[incomingRecord.apiName];
+                        if (additionalWorkForType === undefined) {
+                            result.additionalWork.records[incomingRecord.apiName] = {
+                                ids: [incomingRecord.id],
+                                fields: Array.from(trackedFields),
+                            };
+                        }
+                        else {
+                            additionalWorkForType.ids.push(incomingRecord.id);
+                            additionalWorkForType.fields = Array.from(trackedFields);
+                        }
+                    }
+                    else if (code === 'conflict-drafts' || code === 'conflict-spanning-record') {
+                        const recordByType = result.recordsNeedingRefetch.get(incomingRecord.apiName);
+                        if (recordByType === undefined) {
+                            result.recordsNeedingRefetch.set(incomingRecord.apiName, {
+                                ids: [incomingRecord.id],
+                                fields: Array.from(trackedFields),
+                            });
+                        }
+                        else {
+                            recordByType.ids.push(incomingRecord.id);
+                            recordByType.fields = Array.from(trackedFields);
+                        }
+                    }
+                }
+            }
+        }
+        return result;
+    }
+}
+
 const DEFAULT_BATCH_SIZE = 500;
 const DEFAULT_CONCURRENCY = 6;
 const DEFAULT_GQL_QUERY_BATCH_SIZE = 5;
@@ -15562,8 +15807,10 @@ class PrimingSession extends EventEmitter {
         this.recordLoader = config.recordLoader;
         this.recordIngestor = config.recordIngestor;
         this.objectInfoLoader = config.objectInfoLoader;
+        this.ldsRecordRefresher = config.ldsRecordRefresher;
         this.networkWorkerPool = new AsyncWorkerPool(this.concurrency);
         this.useBatchGQL = ldsPrimingGraphqlBatch.isOpen({ fallback: false });
+        this.conflictPool = new ConflictPool(config.store, this.objectInfoLoader);
     }
     // function that enqueues priming work
     async enqueue(work) {
@@ -15688,7 +15935,9 @@ class PrimingSession extends EventEmitter {
         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.recordIngestor
+            .insertRecords(records, false)
+            .then(({ written, conflicted, errors }) => {
             this.emit('batch-written', {
                 written,
                 conflicted,
@@ -15711,16 +15960,69 @@ class PrimingSession extends EventEmitter {
             if (written.length > 0) {
                 this.emit('primed', Array.from(written));
             }
-            // TODO [W-12436213]: implement conflict resolution
+            // if any records could not be written to the store because there were conflicts, handle the conflicts
+            if (conflicted.length > 0) {
+                this.handleWriteConflicts(records, conflicted, abortController);
+            }
+        });
+    }
+    async handleWriteConflicts(records, conflicted, abortController) {
+        const result = await this.conflictPool.enqueueConflictedRecords(records.filter((x) => conflicted.includes(x.id)), abortController);
+        if (abortController.aborted) {
+            return;
+        }
+        if (Object.keys(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);
+        }
+        if (result.resolvedRecords.length > 0) {
+            this.emit('conflict', {
+                ids: result.resolvedRecords,
+                resolution: 'priming-merge',
+            });
+            this.emit('primed', result.resolvedRecords);
+        }
+        if (result.recordsToWrite.length > 0) {
+            const { written, errors, conflicted } = await this.recordIngestor.insertRecords(result.recordsToWrite, true);
+            if (written.length > 0) {
+                const ids = Array.from(written);
+                this.emit('conflict', { ids, resolution: 'priming-merge' });
+                this.emit('primed', ids);
+            }
+            if (errors.length > 0) {
+                errors.forEach(({ ids, message }) => {
+                    this.emit('error', {
+                        ids,
+                        code: 'unknown',
+                        message: message,
+                    });
+                });
+            }
             if (conflicted.length > 0) {
-                // for now emit conlicts as errors
                 this.emit('error', {
-                    ids: Array.from(conflicted),
+                    ids: conflicted,
                     code: 'unknown',
-                    message: 'conflict when persisting record',
+                    message: 'unexpected write conflict',
                 });
             }
-        });
+        }
+        if (result.recordsNeedingRefetch.size > 0) {
+            const { loaded, errored } = await this.ldsRecordRefresher.loadRecords(result.recordsNeedingRefetch);
+            if (loaded.length > 0) {
+                this.emit('conflict', { resolution: 'lds-refresh', ids: loaded });
+                this.emit('primed', loaded);
+            }
+            if (errored.length > 0) {
+                this.emit('error', {
+                    ids: errored,
+                    code: 'unknown',
+                    message: `could not resolve conflicts`,
+                });
+            }
+        }
     }
     async fetchMetadata(batches) {
         const apiNames = Array.from(batches.reduce((acc, x) => {
@@ -15961,6 +16263,9 @@ function instrumentPrimingSession(session) {
     session.on('primed', ({ length }) => {
         reportPrimingSuccess(length);
     });
+    session.on('conflict', ({ ids, resolution }) => {
+        reportPrimingConflict(resolution, ids.length);
+    });
     return session;
 }
 
@@ -16142,19 +16447,72 @@ function batchArray(arr, batchSize = BATCH_SIZE) {
     return batches;
 }
 
+/**
+ * A polyfill for Promise.allSettled
+ * @param promises An array of promises
+ * @returns the result of all the promises when they either fulfill or reject
+ */
+function allSettled(promises) {
+    let wrappedPromises = promises.map((p) => Promise.resolve(p).then((value) => ({ status: 'fulfilled', value }), (reason) => ({ status: 'rejected', reason })));
+    return Promise.all(wrappedPromises);
+}
+
+class LdsPrimingRecordRefresher {
+    constructor(getRecordsAdapter) {
+        this.getRecordsAdapter = getRecordsAdapter;
+    }
+    async loadRecords(records) {
+        const requestedRecords = new Set();
+        const promises = Array.from(records).flatMap(([_apiName, value]) => {
+            value.ids.forEach((id) => requestedRecords.add(id));
+            return Promise.resolve(this.getRecordsAdapter({
+                records: [
+                    {
+                        recordIds: value.ids,
+                        optionalFields: value.fields.map((f) => `${_apiName}.${f}`),
+                    },
+                ],
+            }));
+        });
+        const promiseResults = await allSettled(promises);
+        const loaded = [];
+        promiseResults.forEach((promiseResult) => {
+            if (promiseResult.status === 'fulfilled') {
+                const batchResultRepresenatation = promiseResult.value;
+                if (batchResultRepresenatation &&
+                    batchResultRepresenatation.state === 'Fulfilled') {
+                    batchResultRepresenatation.data.results.forEach((result) => {
+                        if (result.statusCode === 200) {
+                            const id = result.result.id;
+                            loaded.push(id);
+                            requestedRecords.delete(id);
+                        }
+                    });
+                }
+            }
+        });
+        // errored contains all the requestedRecords that weren't loaded
+        const errored = Array.from(requestedRecords);
+        return { loaded, errored };
+    }
+}
+
 function primingSessionFactory(config) {
     const { store, objectInfoService, getLuvio } = config;
     const networkAdapter = new NimbusPrimingNetworkAdapter();
     const recordLoader = new RecordLoaderGraphQL(networkAdapter);
-    const recordIngestor = new RecordIngestor(new SqlitePrimingStore(getLuvio, store), getLuvio);
+    const primingStore = new SqlitePrimingStore(getLuvio, store);
+    const recordIngestor = new RecordIngestor(primingStore, getLuvio);
     const session = new PrimingSession({
         recordLoader,
         recordIngestor,
+        store: primingStore,
         objectInfoLoader: {
             getObjectInfos: objectInfoService.getObjectInfos.bind(objectInfoService),
         },
         concurrency: config.concurrency,
         batchSize: config.batchSize,
+        ldsRecordRefresher: new LdsPrimingRecordRefresher(config.getRecords),
     });
     return instrumentPrimingSession(session);
 }
@@ -16168,6 +16526,7 @@ let lazyEnvironment;
 let lazyBaseDurableStore;
 let lazyNetworkAdapter;
 let lazyObjectInfoService;
+let lazyGetRecords;
 /**
  * This returns the LDS on Mobile Runtime singleton object.
  */
@@ -16238,6 +16597,7 @@ function getRuntime() {
         lazyLuvio = new Luvio(lazyEnvironment, {
             instrument: instrumentLuvio,
         });
+        lazyGetRecords = getRecordsAdapterFactory(lazyLuvio);
         // Currently instruments store runtime perf
         setupMobileInstrumentation(lazyLuvio, store);
         // If the inspection nimbus plugin is configured, inspection is enabled otherwise this is a no-op
@@ -16292,6 +16652,7 @@ function getRuntime() {
                 getLuvio: () => lazyLuvio,
                 concurrency: config.concurrency,
                 batchSize: config.batchSize,
+                getRecords: lazyGetRecords,
             });
         },
     };
@@ -16310,4 +16671,4 @@ register({
 });
 
 export { getRuntime, registerReportObserver, reportGraphqlQueryParseError };
-// version: 1.208.0-75bd0667c
+// version: 1.209.0-6b633d53a

package/sfdc/types/instrumentation/metrics.d.ts

@@ -14,3 +14,4 @@ export declare function reportDraftAwareContentVersionSynthesizeCalls(mimeType:
 export declare function reportPrimingSessionCreated(): void;
 export declare function reportPrimingError(errorType: string, recordCount: number): void;
 export declare function reportPrimingSuccess(recordCount: number): void;
+export declare function reportPrimingConflict(resolutionType: string, recordCount: number): void;

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

@@ -1,12 +1,14 @@
 import { PrimingSession } from '@salesforce/lds-priming';
-import type { Luvio } from '@luvio/engine';
+import type { Adapter, Luvio } from '@luvio/engine';
 import type { NimbusSqliteStore } from '@salesforce/lds-store-nimbus';
 import type { ObjectInfoService } from '../main';
+import type { BatchRepresentation, GetRecordsConfig } from '@salesforce/lds-adapters-uiapi';
 export interface PrimingSessionFactoryConfig {
     store: NimbusSqliteStore;
     objectInfoService: ObjectInfoService;
     getLuvio: () => Luvio;
     concurrency?: number;
     batchSize?: number;
+    getRecords: Adapter<GetRecordsConfig, BatchRepresentation>;
 }
 export declare function primingSessionFactory(config: PrimingSessionFactoryConfig): PrimingSession;