@salesforce/lds-runtime-mobile 1.244.0 → 1.246.0

package/dist/main.js

@@ -16,7 +16,7 @@ import { setupInstrumentation, instrumentAdapter as instrumentAdapter$1, instrum
 import { HttpStatusCode, StoreKeySet, serializeStructuredKey, StringKeyInMemoryStore, 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 { RECORD_ID_PREFIX, RECORD_FIELDS_KEY_JUNCTION, isStoreKeyRecordViewEntity, getRecordId18, RECORD_REPRESENTATION_NAME, extractRecordIdFromStoreKey, keyBuilderQuickActionExecutionRepresentation, ingestQuickActionExecutionRepresentation, keyBuilderContentDocumentCompositeRepresentation, getResponseCacheKeysContentDocumentCompositeRepresentation, keyBuilderFromTypeContentDocumentCompositeRepresentation, ingestContentDocumentCompositeRepresentation, keyBuilderRecord, RECORD_VIEW_ENTITY_ID_PREFIX, getTypeCacheKeysRecord, keyBuilderFromTypeRecordRepresentation, ingestRecord, RecordRepresentationRepresentationType, ObjectInfoRepresentationType, getRecordAdapterFactory, getObjectInfoAdapterFactory, getObjectInfosAdapterFactory, UiApiNamespace, RecordRepresentationType, RecordRepresentationTTL, RecordRepresentationVersion, getRecordsAdapterFactory } from '@salesforce/lds-adapters-uiapi';
+import { RECORD_ID_PREFIX, RECORD_FIELDS_KEY_JUNCTION, isStoreKeyRecordViewEntity, getRecordId18, RECORD_REPRESENTATION_NAME, extractRecordIdFromStoreKey, keyBuilderQuickActionExecutionRepresentation, ingestQuickActionExecutionRepresentation, keyBuilderContentDocumentCompositeRepresentation, getResponseCacheKeysContentDocumentCompositeRepresentation, keyBuilderFromTypeContentDocumentCompositeRepresentation, ingestContentDocumentCompositeRepresentation, keyBuilderRecord, RECORD_VIEW_ENTITY_ID_PREFIX, getTypeCacheKeysRecord, keyBuilderFromTypeRecordRepresentation, ingestRecord, RecordRepresentationRepresentationType, ObjectInfoRepresentationType, getRecordAdapterFactory, getObjectInfoAdapterFactory, getObjectInfosAdapterFactory, getObjectInfoDirectoryAdapterFactory, UiApiNamespace, RecordRepresentationType, RecordRepresentationTTL, RecordRepresentationVersion, keyBuilderObjectInfo, ObjectInfoDirectoryEntryRepresentationType, 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';
@@ -10316,16 +10316,18 @@ function injectFilter(filterNode, idState, parentPath, isParentPolymorphic, obje
                         if (!isIdField) {
                             let subSelectionNodes = [];
                             let subFieldsHasId = false;
-                            filterNode.value.fields.forEach((subFieldNode) => {
-                                // Check if the filter field has the 'Id'
-                                if (isFieldAnIdField(subFieldNode.name.value, objectInfos[objectInfoName])) {
-                                    subFieldsHasId = true;
-                                    updateIDInfo(subFieldNode, idState, draftFunctions);
-                                }
-                                // try injecting the fields within predicate no matter it has relation or not.
-                                let subResults = injectFilter(subFieldNode, idState, curPath, isPolymorphicField, objectInfos, pathToObjectApiNamesMap, draftFunctions, existingFields ? existingFields[0] : undefined);
-                                subSelectionNodes = subSelectionNodes.concat(subResults);
-                            });
+                            if (isSpanning) {
+                                filterNode.value.fields.forEach((subFieldNode) => {
+                                    // Check if the filter field has the 'Id'
+                                    if (isFieldAnIdField(subFieldNode.name.value, objectInfos[objectInfoName])) {
+                                        subFieldsHasId = true;
+                                        updateIDInfo(subFieldNode, idState, draftFunctions);
+                                    }
+                                    // try injecting the fields within predicate no matter it has relation or not.
+                                    let subResults = injectFilter(subFieldNode, idState, curPath, isPolymorphicField, objectInfos, pathToObjectApiNamesMap, draftFunctions, existingFields ? existingFields[0] : undefined);
+                                    subSelectionNodes = subSelectionNodes.concat(subResults);
+                                });
+                            }
                             if (!subFieldsHasId) {
                                 // Check if the query field has the 'Id'
                                 const existingIdsInQuery = existingFields &&
@@ -10354,6 +10356,7 @@ function injectFilter(filterNode, idState, parentPath, isParentPolymorphic, obje
                             }
                             //Inject Conditions: 1. Same field does not exist 2. Same fields has different children. 3. Filter spanning field does not have Id. 4. InLineFragment does not have the '__typename' field
                             if (!existingFields ||
+                                existingFields.length === 0 ||
                                 subSelectionNodes.length > 0 ||
                                 (isSpanning && !subFieldsHasId) ||
                                 (isInlineFragment && !isTypeNameExisting)) {
@@ -12481,30 +12484,36 @@ function makeRecordDenormalizingDurableStore(luvio, durableStore, getStoreRecord
         const operationsWithDenormedRecords = [];
         for (let i = 0, len = operations.length; i < len; i++) {
             const operation = operations[i];
-            if (durableStore.plugin !== undefined &&
-                durableStore.plugin.supportsBatchUpdates !== undefined &&
-                durableStore.plugin.supportsBatchUpdates() === true) {
-                if (operation.segment !== DefaultDurableSegment ||
-                    operation.type !== 'setEntries') {
-                    operationsWithDenormedRecords.push(operation);
-                    continue;
+            if (operation.type === 'setMetadata') {
+                // if setMetadata also contains entry data then it needs to be denormalized.
+                const keys$1 = keys$3(operation.entries);
+                if (keys$1.length > 0) {
+                    const firstKey = keys$1[0];
+                    // casted to any to check if data exists
+                    const firstEntry = operation.entries[firstKey];
+                    // it is not possible for setMetadata to contain entries with both data and no data in the same operation.
+                    // this is determined by the plugin supporting update batch calls before it gets to this HOF.
+                    // so we only need to check one entry to confirm this for performance
+                    if (firstEntry.data !== undefined) {
+                        operationsWithDenormedRecords.push({
+                            ...operation,
+                            entries: denormalizeEntries(operation.entries),
+                        });
+                    }
+                    else {
+                        operationsWithDenormedRecords.push(operation);
+                    }
                 }
-                operationsWithDenormedRecords.push({
-                    ...operation,
-                    entries: denormalizeEntries(operation.entries),
-                });
+                continue;
             }
-            else {
-                if (operation.segment !== DefaultDurableSegment ||
-                    operation.type === 'evictEntries') {
-                    operationsWithDenormedRecords.push(operation);
-                    continue;
-                }
-                operationsWithDenormedRecords.push({
-                    ...operation,
-                    entries: denormalizeEntries(operation.entries),
-                });
+            if (operation.segment !== DefaultDurableSegment || operation.type === 'evictEntries') {
+                operationsWithDenormedRecords.push(operation);
+                continue;
             }
+            operationsWithDenormedRecords.push({
+                ...operation,
+                entries: denormalizeEntries(operation.entries),
+            });
         }
         return durableStore.batchOperations(operationsWithDenormedRecords);
     };
@@ -13073,7 +13082,7 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
         // Fulfilled snapshot (this only happens in this code path if
         // the error is network error or 504), otherwise we spread over
         // the non-eval'ed snapshot (which will be either Fulfilled or Stale)
-        return nonEvaluatedSnapshot.state === 'Error'
+        const resultSnapshot = nonEvaluatedSnapshot.state === 'Error'
             ? createLocalEvalSnapshot(gqlResult, seenRecords, recordId, rebuildWithLocalEval)
             : {
                 ...nonEvaluatedSnapshot,
@@ -13082,6 +13091,22 @@ function draftAwareGraphQLAdapterFactory(userId, objectInfoService, store, luvio
                 seenRecords,
                 rebuildWithLocalEval,
             };
+        const { refresh, state } = resultSnapshot;
+        if (state !== 'Error' && refresh) {
+            // after refreshing a graphql snapshot, we want to force a rebuild regardless
+            // of if the call failed or not or if the data changed or not because we want
+            // to make sure any potential new drafts are picked up
+            resultSnapshot.refresh = {
+                ...refresh,
+                resolve: (config) => {
+                    return refresh.resolve(config).finally(() => {
+                        luvio.storePublish(resultSnapshot.recordId, undefined);
+                        luvio.storeBroadcast();
+                    });
+                },
+            };
+        }
+        return resultSnapshot;
     };
 }
 
@@ -15023,6 +15048,7 @@ function buildInternalAdapters(store, networkAdapter, durableStore, ensureObject
     const getRecord = getRecordAdapterFactory(luvio);
     const getObjectInfo = getObjectInfoAdapterFactory(luvio);
     const getObjectInfos = getObjectInfosAdapterFactory(luvio);
+    const getObjectInfoDirectory = getObjectInfoDirectoryAdapterFactory(luvio);
     return {
         luvio,
         durableEnvironment,
@@ -15030,37 +15056,37 @@ function buildInternalAdapters(store, networkAdapter, durableStore, ensureObject
             getRecord,
             getObjectInfo,
             getObjectInfos,
+            getObjectInfoDirectory,
         },
     };
 }
 
-const OBJECT_INFO_PREFIX_SEGMENT = 'OBJECT_INFO_PREFIX_SEGMENT';
 class ObjectInfoService {
-    constructor(getObjectInfoAdapter, getObjectInfosAdapter, durableStore) {
+    constructor(getObjectInfoAdapter, getObjectInfosAdapter, getObjectInfoDirectoryAdapter, durableStore) {
+        this.getObjectInfoAdapter = getObjectInfoAdapter;
+        this.getObjectInfosAdapter = getObjectInfosAdapter;
+        this.getObjectInfoDirectoryAdapter = getObjectInfoDirectoryAdapter;
+        this.durableStore = durableStore;
         this.apiNameForPrefix = async (prefix) => {
-            const entries = await this.durableStore.getAllEntries(OBJECT_INFO_PREFIX_SEGMENT);
-            const missingError = new Error(`ObjectInfo for ${prefix} prefix is not primed into the durable store`);
-            if (entries === undefined) {
-                throw missingError;
+            if (this.keyPrefixToApiNameMemoryCache[prefix] !== undefined) {
+                return this.keyPrefixToApiNameMemoryCache[prefix];
             }
-            const keys = Object.keys(entries);
-            for (let i = 0, len = keys.length; i < len; i++) {
-                const entry = entries[keys[i]];
-                if (prefix === entry.data.keyPrefix) {
-                    return entry.data.apiName;
-                }
+            await this.loadObjectInfoMaps();
+            const apiName = this.keyPrefixToApiNameMemoryCache[prefix];
+            if (apiName === undefined) {
+                throw Error(`ObjectInfo for ${prefix} prefix is not primed into the durable store`);
             }
-            throw missingError;
+            return apiName;
         };
         this.ensureObjectInfoCached = async (apiName, entry) => {
+            if (entry !== undefined) {
+                const { keyPrefix, apiName } = entry;
+                return this.updateObjectInfoMapping(keyPrefix, apiName);
+            }
             const exists = await this.isObjectInfoInDurableStore(apiName);
             if (exists) {
                 return;
             }
-            if (entry !== undefined) {
-                // Since ObjectInfo is provided, no need to fetch the snapshot
-                return this.createObjectInfoMapping(apiName, entry);
-            }
             // ObjectInfo is not present in Durable store. Fetch
             const snapshot = await this.getObjectInfoAdapter({
                 objectApiName: apiName,
@@ -15069,46 +15095,34 @@ class ObjectInfoService {
                 throw Error(`No snapshot found for apiName ${apiName}`);
             }
             if (snapshot.data !== null && snapshot.data !== undefined) {
-                return this.createObjectInfoMapping(apiName, snapshot.data);
+                const { keyPrefix, apiName } = snapshot.data;
+                return this.updateObjectInfoMapping(keyPrefix, apiName);
             }
         };
-        /**
-         * Caches ObjectInfo(ApiName and KeyPrefix) in Durable Store
-         *
-         * @param apiName eg: 'Account'
-         * @param objectInfo Object Info
-         *
-         * @returns Promise
-         */
-        this.createObjectInfoMapping = (apiName, objectInfo) => {
-            const { keyPrefix } = objectInfo;
-            const entries = {
-                [apiName]: {
-                    data: {
-                        apiName,
-                        keyPrefix,
-                    },
-                },
-            };
-            this.objectInfoMemoryCache[apiName] = keyPrefix;
-            return this.durableStore.setEntries(entries, OBJECT_INFO_PREFIX_SEGMENT);
-        };
         this.isObjectInfoInDurableStore = async (apiName) => {
-            if (this.objectInfoMemoryCache[apiName] !== undefined) {
+            if (this.apiNameToKeyPrefixMemoryCache[apiName] !== undefined) {
                 return Promise.resolve(true);
             }
-            const entries = await this.durableStore.getEntries([apiName], OBJECT_INFO_PREFIX_SEGMENT);
-            if (entries === undefined || entries[apiName] === undefined) {
-                return false;
+            await this.loadObjectInfoMaps();
+            return this.apiNameToKeyPrefixMemoryCache[apiName] !== undefined;
+        };
+        this.loadObjectInfoMaps = async () => {
+            const rows = (await this.durableStore.query(`SELECT json_extract(data, '$.apiName') as ApiName, json_extract(data, '$.keyPrefix') as keyPrefix from lds_data where key like '%ObjectInfoRepresentation%'`, [])).rows;
+            for (const row of rows) {
+                const apiName = row[0];
+                const keyPrefix = row[1];
+                this.updateObjectInfoMapping(keyPrefix, apiName);
             }
-            this.objectInfoMemoryCache[apiName] = entries[apiName].data.keyPrefix;
-            return true;
         };
-        this.getObjectInfoAdapter = getObjectInfoAdapter;
-        this.getObjectInfosAdapter = getObjectInfosAdapter;
-        this.durableStore = durableStore;
-        // Local in-memory cache for ObjectInfo entries seen in DurableStore eg: {'Account': 001}
-        this.objectInfoMemoryCache = create$1(null);
+        this.updateObjectInfoMapping = (keyPrefix, apiName) => {
+            this.apiNameToKeyPrefixMemoryCache[apiName] = keyPrefix;
+            if (keyPrefix !== null) {
+                this.keyPrefixToApiNameMemoryCache[keyPrefix] = apiName;
+            }
+        };
+        // Local in-memory cache for apiName to key prefixes
+        this.apiNameToKeyPrefixMemoryCache = create$1(null);
+        this.keyPrefixToApiNameMemoryCache = create$1(null);
     }
     /**
      * Size of return map not necessarily correlated with number of inputs.  The
@@ -15128,10 +15142,20 @@ class ObjectInfoService {
         for (const result of snapshot.data.results) {
             if (result.statusCode === 200) {
                 objectInfos[result.result.apiName] = result.result;
+                this.updateObjectInfoMapping(result.result.keyPrefix, result.result.apiName);
             }
         }
         return objectInfos;
     }
+    async getObjectInfoDirectory() {
+        const snapshot = await this.getObjectInfoDirectoryAdapter({});
+        if (!snapshot ||
+            !snapshot.data ||
+            (snapshot.state !== 'Fulfilled' && snapshot.state !== 'Stale')) {
+            return undefined;
+        }
+        return snapshot.data;
+    }
 }
 
 function instrumentGraphQLEval(adapter) {
@@ -15475,6 +15499,7 @@ class NimbusSqliteStore {
             ...additionalTableMap,
             [DefaultDurableSegment]: new LdsDataTable(plugin),
         };
+        this.supportsBatchUpdates = plugin.supportsBatchUpdates !== undefined;
     }
     isEvalSupported() {
         return true;
@@ -15509,16 +15534,15 @@ class NimbusSqliteStore {
     setMetadata(entries, segment) {
         const table = this.getTable(segment);
         let operation;
-        if (this.plugin.supportsBatchUpdates === undefined ||
-            this.plugin.supportsBatchUpdates() === false) {
+        if (this.supportsBatchUpdates) {
+            operation = table.metadataToUpdateOperations(entries, segment);
+        }
+        else {
             operation = table.entriesToUpsertOperations(entries, segment);
             // manually set the context type on the upsert so notifications do not notify rebuilds without
             // plugin updates
             operation.context.type = 'setMetadata';
         }
-        else {
-            operation = table.metadataToUpdateOperations(entries, segment);
-        }
         return this.batchOperationAsPromise([operation]);
     }
     batchOperations(operations) {
@@ -15529,17 +15553,16 @@ class NimbusSqliteStore {
             }
             else if (cur.type === 'setMetadata') {
                 const table = this.getTable(cur.segment);
-                if (this.plugin.supportsBatchUpdates === undefined ||
-                    this.plugin.supportsBatchUpdates() === false) {
+                if (this.supportsBatchUpdates) {
+                    acc.push(table.metadataToUpdateOperations(cur.entries, cur.segment));
+                }
+                else {
                     const upsert = table.entriesToUpsertOperations(cur.entries, cur.segment);
                     // manually set the context type on the upsert so notifications do not notify rebuilds without
                     // plugin updates
                     upsert.context.type = 'setMetadata';
                     acc.push(upsert);
                 }
-                else {
-                    acc.push(table.metadataToUpdateOperations(cur.entries, cur.segment));
-                }
             }
             else {
                 acc.push(this.idsToDeleteOperation(cur.ids, cur.segment));
@@ -16715,17 +16738,34 @@ function instrumentPrimingSession(session) {
 const apiVersion = `v60.0`;
 const batchEndPointPath = `/services/data/${apiVersion}/graphql/batch`;
 const endPointPath = `/services/data/${apiVersion}/graphql`;
+const batchObjectInfoEndpoint = `/services/data/${apiVersion}/ui-api/object-info/batch`;
+const objectInfoDirectoryEndpoint = `/services/data/${apiVersion}/ui-api/object-info`;
 class NimbusPrimingNetworkAdapter {
+    sendRequestWithAbort(request, abortController, onResponse, onError) {
+        let listener;
+        const unregisterListener = () => {
+            if (listener) {
+                abortController.removeEventListener(listener);
+            }
+        };
+        return __nimbus.plugins.LdsNetworkAdapter
+            .sendRequest(request, (response) => {
+            unregisterListener();
+            onResponse(response);
+        }, (error) => {
+            unregisterListener();
+            onError(error);
+        })
+            .then((cancellationToken) => {
+            listener = () => {
+                __nimbus.plugins.LdsNetworkAdapter.cancelRequest(cancellationToken);
+            };
+            abortController.addEventListener(listener);
+        });
+    }
     postBatchGraphQL(configs, abortController) {
         return new Promise((resolve, reject) => {
-            let listener;
-            const unregisterListener = () => {
-                if (listener) {
-                    abortController.removeEventListener(listener);
-                }
-            };
-            __nimbus.plugins.LdsNetworkAdapter
-                .sendRequest({
+            this.sendRequestWithAbort({
                 method: 'POST',
                 path: batchEndPointPath,
                 body: JSON.stringify({
@@ -16735,8 +16775,7 @@ class NimbusPrimingNetworkAdapter {
                 queryParams: {},
                 priority: 'background',
                 observabilityContext: {},
-            }, (response) => {
-                unregisterListener();
+            }, abortController, (response) => {
                 const { body } = response;
                 if (body) {
                     const { results } = JSON.parse(body);
@@ -16752,27 +16791,13 @@ class NimbusPrimingNetworkAdapter {
                     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;
-            const unregisterListener = () => {
-                if (listener) {
-                    abortController.removeEventListener(listener);
-                }
-            };
-            __nimbus.plugins.LdsNetworkAdapter
-                .sendRequest({
+            this.sendRequestWithAbort({
                 method: 'POST',
                 path: endPointPath,
                 body: JSON.stringify({
@@ -16783,8 +16808,7 @@ class NimbusPrimingNetworkAdapter {
                 queryParams: {},
                 priority: 'background',
                 observabilityContext: {},
-            }, (response) => {
-                unregisterListener();
+            }, abortController, (response) => {
                 const { body } = response;
                 if (body) {
                     resolve(JSON.parse(body));
@@ -16793,14 +16817,64 @@ class NimbusPrimingNetworkAdapter {
                     reject(new Error(`No body returned from ${endPointPath} endpoint`));
                 }
             }, (error) => {
-                unregisterListener();
                 reject(error);
-            })
-                .then((cancellationToken) => {
-                listener = () => {
-                    __nimbus.plugins.LdsNetworkAdapter.cancelRequest(cancellationToken);
-                };
-                abortController.addEventListener(listener);
+            });
+        });
+    }
+    getObjectInfoDirectory(abortController) {
+        return new Promise((resolve, reject) => {
+            this.sendRequestWithAbort({
+                method: 'GET',
+                path: objectInfoDirectoryEndpoint,
+                body: null,
+                headers: {},
+                queryParams: {},
+                priority: 'background',
+                observabilityContext: {},
+            }, abortController, (response) => {
+                const { body } = response;
+                if (body) {
+                    resolve(JSON.parse(body).objects);
+                }
+                else {
+                    reject(new Error(`No body returned from ${endPointPath} endpoint`));
+                }
+            }, (error) => {
+                reject(error);
+            });
+        });
+    }
+    getObjectInfos(apiName, abortController) {
+        return new Promise((resolve, reject) => {
+            const map = new Map();
+            if (apiName.length === 0) {
+                resolve(map);
+            }
+            this.sendRequestWithAbort({
+                method: 'GET',
+                path: `${batchObjectInfoEndpoint}/${apiName.join(',')}`,
+                body: null,
+                headers: {},
+                queryParams: {},
+                priority: 'background',
+                observabilityContext: {},
+            }, abortController, (response) => {
+                const { body } = response;
+                if (body) {
+                    const results = JSON.parse(body).results;
+                    results.forEach((result) => {
+                        // only populate the map if the status code is 200, caller needs to check for missing keys
+                        if (result.statusCode === 200) {
+                            map.set(result.result.apiName, result.result);
+                        }
+                    });
+                    resolve(map);
+                }
+                else {
+                    reject(new Error(`No body returned from ${endPointPath} endpoint`));
+                }
+            }, (error) => {
+                reject(error);
             });
         });
     }
@@ -16809,6 +16883,10 @@ class NimbusPrimingNetworkAdapter {
 // ref: https://gnome.pages.gitlab.gnome.org/tracker/docs/developer/limits.html?gi-language=c
 const SQLITE_MAX_VARIABLE_NUMBER = 999;
 const PARAMS_PER_RECORD = 3;
+/**
+ * No key builder (or adapter) exists for the object info directory, we need to build the key manually
+ */
+const ObjectInfoDirectoryKey = `${UiApiNamespace}::${ObjectInfoDirectoryEntryRepresentationType}:`;
 // We need to batch the records to avoid hitting the SQLITE_MAX_VARIABLE_NUMBER limit. Each record has 3 parameters
 const BATCH_SIZE = Math.floor(SQLITE_MAX_VARIABLE_NUMBER / PARAMS_PER_RECORD);
 class SqlitePrimingStore {
@@ -16873,6 +16951,44 @@ class SqlitePrimingStore {
             };
         }
     }
+    async readObjectInfoDirectory() {
+        const sql = 'SELECT data FROM lds_data WHERE key = ?';
+        const params = [ObjectInfoDirectoryKey];
+        const result = await this.store.query(sql, params);
+        if (result.rows.length === 1) {
+            return JSON.parse(result.rows[0][0]);
+        }
+        return undefined;
+    }
+    async readObjectApiNames() {
+        const sql = 'SELECT key FROM lds_data WHERE key like ?';
+        const params = [`%${ObjectInfoRepresentationType}%`];
+        const result = await this.store.query(sql, params);
+        const apiNames = new Set();
+        result.rows.forEach((row) => {
+            const key = row[0];
+            const parts = key.split(':');
+            apiNames.add(parts[parts.length - 1]);
+        });
+        return apiNames;
+    }
+    writeObjectInfoDirectory(directory) {
+        const sql = 'INSERT or IGNORE into lds_data (key, data) values (?, ?)';
+        const params = [ObjectInfoDirectoryKey, JSON.stringify(directory)];
+        return this.store.query(sql, params).then(() => { });
+    }
+    writeObjectInfos(objectInfos) {
+        const sql = `INSERT or IGNORE into lds_data (key, data) values ${objectInfos
+            .map(() => '(?, ?)')
+            .join(',')};`;
+        const params = [];
+        objectInfos.forEach((objectInfo) => {
+            const key = keyBuilderObjectInfo(this.getLuvio(), { apiName: objectInfo.apiName });
+            params.push(key);
+            params.push(JSON.stringify(objectInfo));
+        });
+        return this.store.query(sql, params).then(() => { });
+    }
 }
 function batchArray(arr, batchSize = BATCH_SIZE) {
     const batches = [];
@@ -16997,13 +17113,13 @@ function getRuntime() {
             : {}, () => getIngestMetadataForInternalAdapters !== undefined
             ? getIngestMetadataForInternalAdapters()
             : {});
-        const { adapters: { getObjectInfo, getObjectInfos, getRecord }, durableEnvironment: internalAdapterDurableEnvironment, luvio: internalLuvio, } = buildInternalAdapters(internalAdapterStore, lazyNetworkAdapter, internalAdapterDurableStore, (apiName, objectInfo) => lazyObjectInfoService.ensureObjectInfoCached(apiName, objectInfo));
+        const { adapters: { getObjectInfo, getObjectInfos, getRecord, getObjectInfoDirectory }, durableEnvironment: internalAdapterDurableEnvironment, luvio: internalLuvio, } = buildInternalAdapters(internalAdapterStore, lazyNetworkAdapter, internalAdapterDurableStore, (apiName, objectInfo) => lazyObjectInfoService.ensureObjectInfoCached(apiName, objectInfo));
         lazyInternalLuvio = internalLuvio;
         getIngestRecordsForInternalAdapters =
             internalAdapterDurableEnvironment.getIngestStagingStoreRecords;
         getIngestMetadataForInternalAdapters =
             internalAdapterDurableEnvironment.getIngestStagingStoreRecords;
-        lazyObjectInfoService = new ObjectInfoService(getObjectInfo, getObjectInfos, internalAdapterDurableStore);
+        lazyObjectInfoService = new ObjectInfoService(getObjectInfo, getObjectInfos, getObjectInfoDirectory, lazyBaseDurableStore);
         // creates a durable store that denormalizes scalar fields for records
         let getIngestRecords;
         let getIngestMetadata;
@@ -17098,6 +17214,7 @@ function getRuntime() {
                 getRecords: lazyGetRecords,
             });
         },
+        nimbusSqliteStore: lazyBaseDurableStore,
     };
 }
 
@@ -17114,4 +17231,4 @@ register({
 });
 
 export { getRuntime, registerReportObserver, reportGraphqlQueryParseError };
-// version: 1.244.0-72e322fff
+// version: 1.246.0-8357100fc

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

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

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

@@ -1,5 +1,6 @@
 import type { PrimingStore, RecordWithMetadata, WriteResult } from '@salesforce/lds-priming';
 import type { Luvio } from '@luvio/engine';
+import type { ObjectInfoDirectoryRepresentation, ObjectInfoRepresentation } from '@salesforce/lds-adapters-uiapi';
 import type { SqliteStore } from '@salesforce/lds-store-sql';
 export declare class SqlitePrimingStore implements PrimingStore {
     private readonly getLuvio;
@@ -8,4 +9,8 @@ export declare class SqlitePrimingStore implements PrimingStore {
     readRecords(ids: string[]): Promise<RecordWithMetadata[]>;
     writeRecords(records: RecordWithMetadata[], overwrite: boolean): Promise<WriteResult>;
     private writeBatch;
+    readObjectInfoDirectory(): Promise<ObjectInfoDirectoryRepresentation | undefined>;
+    readObjectApiNames(): Promise<Set<string>>;
+    writeObjectInfoDirectory(directory: ObjectInfoDirectoryRepresentation): Promise<void>;
+    writeObjectInfos(objectInfos: ObjectInfoRepresentation[]): Promise<void>;
 }

package/dist/types/runtime.d.ts

@@ -1,6 +1,7 @@
 import { Luvio, Environment } from '@luvio/engine';
 import { DraftManager } from '@salesforce/lds-drafts';
 import type { DraftQueue } from '@salesforce/lds-drafts';
+import type { NimbusSqliteStore } from '@salesforce/lds-store-nimbus';
 import type { PrimingSession } from '@salesforce/lds-priming';
 export interface Runtime {
     luvio: Luvio;
@@ -12,6 +13,7 @@ export interface Runtime {
         concurrency?: number;
         batchSize?: number;
     }) => PrimingSession;
+    nimbusSqliteStore: NimbusSqliteStore;
 }
 /**
  * This returns the LDS on Mobile Runtime singleton object.