@salesforce/lwc-adapters-uiapi 1.182.0 → 1.182.1

package/dist/main.js

@@ -12753,6 +12753,7 @@ function toSortedStringArray(value) {
     return undefined;
 }
 
+const adapterName$5 = 'getRecord';
 const oneOfConfigPropertiesIdentifier$1 = [
     'layoutTypes',
     'fields',
@@ -16562,7 +16563,7 @@ const factory$j = (luvio) => function getMruListUi(untrustedConfig, requestConte
         : processListInfo(listInfoPromiseOrSnapshot);
 };
 
-const contextId$4 = `${keyPrefix}__getListUi`;
+const contextId$5 = `${keyPrefix}__getListUi`;
 // eslint-disable-next-line @salesforce/lds/no-invalid-todo
 // TODO RAML - this more properly goes in the generated resource files
 const DEFAULT_PAGE_SIZE = 50;
@@ -16991,7 +16992,7 @@ const factory$i = (luvio) => {
             return listUiAdapter(untrustedConfig, adapterContext, requestContext);
         }
         return null;
-    }, { contextId: contextId$4 });
+    }, { contextId: contextId$5 });
 };
 
 function validate$1r(obj, path = 'ChildRelationshipRepresentation') {
@@ -19774,6 +19775,10 @@ function buildSnapshotRefresh$3(luvio, config) {
         resolve: () => refresh$1(luvio, config),
     };
 }
+function buildObjectInfoSelectorKey(luvio, objectInfo) {
+    const key = keyBuilderFromType$s(luvio, objectInfo);
+    return `${key}__implicit__fields__selector`;
+}
 function refresh$1(luvio, config) {
     const { recordId, layoutTypes, modes: configModes, optionalFields: configOptionalFields, } = config;
     const modes = configModes === undefined ? [DEFAULT_MODE] : configModes;
@@ -19827,7 +19832,13 @@ function getLayoutMapAndObjectInfo(recordId, data) {
         objectInfo,
     };
 }
-function processRecordUiRepresentation(luvio, refresh, recordId, modes, snapshot, optionalFields) {
+function getFields(recordId, data) {
+    const { records } = data;
+    const record = records[recordId];
+    const { fields } = record;
+    return fields;
+}
+function processRecordUiRepresentation(luvio, refresh, recordId, modes, snapshot, adapterContext, optionalFields) {
     if (isErrorSnapshot(snapshot)) {
         return luvio.errorSnapshot(snapshot.error, refresh);
     }
@@ -19842,7 +19853,12 @@ function processRecordUiRepresentation(luvio, refresh, recordId, modes, snapshot
         throw new Error(`RecordUi adapter resolved with a ${snapshot.state} snapshot with undefined data`);
     }
     const { layoutMap, objectInfo } = getLayoutMapAndObjectInfo(recordId, data);
-    return getRecord$1(luvio, refresh, recordId, layoutMap, objectInfo, optionalFields);
+    if (objectInfo.layoutable) {
+        return getRecordForLayoutableEntities(luvio, refresh, recordId, layoutMap, objectInfo, optionalFields);
+    }
+    else {
+        return getRecordForNonLayoutableEntities(luvio, adapterContext, refresh, recordId, objectInfo, optionalFields, getFields(recordId, data));
+    }
 }
 const recordLayoutFragmentSelector = [
     {
@@ -19869,8 +19885,20 @@ function getFieldsFromLayoutMap(layoutMap, objectInfo) {
     }
     return dedupe(fields).sort();
 }
-function getRecord$1(luvio, refresh, recordId, layoutMap, objectInfo, configOptionalFields) {
+function getRecordForLayoutableEntities(luvio, refresh, recordId, layoutMap, objectInfo, configOptionalFields) {
     const fields = getFieldsFromLayoutMap(layoutMap, objectInfo);
+    return getRecord$1(luvio, refresh, recordId, fields, configOptionalFields);
+}
+function getRecordForNonLayoutableEntities(luvio, adapterContext, refresh, recordId, objectInfo, configOptionalFields, configFields) {
+    const fields = keys(configFields ? configFields : {}).map((key) => `${objectInfo.apiName}.${key}`);
+    // W-12697744
+    // Set the implicit fields received from the server in adapter context
+    // This ensures that the implicit fields are available when data is read locally or from durable store
+    const selectorKey = buildObjectInfoSelectorKey(luvio, objectInfo);
+    adapterContext.set(selectorKey, fields);
+    return getRecord$1(luvio, refresh, recordId, fields, configOptionalFields);
+}
+function getRecord$1(luvio, refresh, recordId, fields, configOptionalFields) {
     const optionalFields = configOptionalFields === undefined ? [] : dedupe(configOptionalFields).sort();
     // We know what fields we need so delegate to getRecordByFields
     // This should be a cache hit because we just fetched the record-ui
@@ -19892,7 +19920,7 @@ function getRecord$1(luvio, refresh, recordId, layoutMap, objectInfo, configOpti
     return recordSnapshotOrPromise;
 }
 function buildNetworkSnapshot$V(context, coercedAdapterRequestContext) {
-    const { config, luvio } = context;
+    const { config, luvio, adapterContext } = context;
     const { recordId } = config;
     const optionalFields = config.optionalFields === undefined ? [] : dedupe(config.optionalFields).sort();
     const refresh = buildSnapshotRefresh$3(luvio, config);
@@ -19929,7 +19957,7 @@ function buildNetworkSnapshot$V(context, coercedAdapterRequestContext) {
         modes,
         optionalFields,
     };
-    return buildNetworkSnapshot$W(luvio, recordUiConfig, dispatchOptions).then((snapshot) => processRecordUiRepresentation(luvio, refresh, recordId, modes, snapshot, optionalFields));
+    return buildNetworkSnapshot$W(luvio, recordUiConfig, dispatchOptions).then((snapshot) => processRecordUiRepresentation(luvio, refresh, recordId, modes, snapshot, adapterContext, optionalFields));
 }
 function buildRecordLayoutCachedSnapshot(context, storeLookup) {
     const { config, luvio } = context;
@@ -19981,13 +20009,13 @@ const buildLayoutModeCacheSnapshot = (apiName, recordTypeId, layoutType, mode) =
  * @param  {GetRecordLayoutTypeConfig} config
  * @param  {BuildCachedSnapshot<BuildSnapshotContext} cachedSnapshot
  */
-function makeCacheOnlySnapshot(luvio, config, cachedSnapshot) {
+function makeCacheOnlySnapshot(luvio, config, adapterContext, cachedSnapshot) {
     return luvio.applyCachePolicy({
         cachePolicy: {
             // only looking in the cache so we can check for L2 data offline
             type: 'only-if-cached',
         },
-    }, { config, luvio }, cachedSnapshot, 
+    }, { config, luvio, adapterContext }, cachedSnapshot, 
     // this won't be invoked since we're requesting only-if-cached
     () => {
         throw Error('buildNetworkSnapshot should not be called for only-if-cached policy');
@@ -20000,37 +20028,50 @@ function makeCacheOnlySnapshot(luvio, config, cachedSnapshot) {
  * @param  {GetRecordLayoutTypeConfig} config
  * @param  {AdapterRequestContext} requestContext?
  */
-function makeNetworkOnlySnapshot(luvio, config, requestContext) {
-    return luvio.applyCachePolicy(requestContext || {}, { config, luvio }, () => {
+function makeNetworkOnlySnapshot(luvio, config, adapterContext, requestContext) {
+    return luvio.applyCachePolicy(requestContext || {}, { config, luvio, adapterContext }, () => {
         return undefined;
     }, buildNetworkSnapshot$V);
 }
-function getRecordLayoutType(luvio, config, requestContext) {
+function getRecordLayoutType(luvio, config, adapterContext, requestContext) {
     // lookup record layout
-    const recordLayoutSnapshotOrPromise = makeCacheOnlySnapshot(luvio, config, buildRecordLayoutCachedSnapshot);
+    const recordLayoutSnapshotOrPromise = makeCacheOnlySnapshot(luvio, config, adapterContext, buildRecordLayoutCachedSnapshot);
     return runSnapshotOrPromise(recordLayoutSnapshotOrPromise, (recordLayoutSnapshot) => {
         // if record layout is not fulfulled or data is undefined send to the network
         if (recordLayoutSnapshot.state === 'Unfulfilled' ||
             recordLayoutSnapshot.state === 'Error' ||
             recordLayoutSnapshot.data === undefined) {
-            return makeNetworkOnlySnapshot(luvio, config, requestContext);
+            return makeNetworkOnlySnapshot(luvio, config, adapterContext, requestContext);
         }
         // lookup object info
-        const objectInfoSnapshotOrPromise = makeCacheOnlySnapshot(luvio, config, buildObjectInfoCacheSnapshot(recordLayoutSnapshot));
+        const objectInfoSnapshotOrPromise = makeCacheOnlySnapshot(luvio, config, adapterContext, buildObjectInfoCacheSnapshot(recordLayoutSnapshot));
         return runSnapshotOrPromise(objectInfoSnapshotOrPromise, (objectInfoSnapshot) => {
             const { layoutTypes } = config;
             // if not fulfilled or missing data send to the network
             if (objectInfoSnapshot.state === 'Unfulfilled' ||
                 objectInfoSnapshot.state === 'Error' ||
                 objectInfoSnapshot.data === undefined) {
-                return makeNetworkOnlySnapshot(luvio, config, requestContext);
+                return makeNetworkOnlySnapshot(luvio, config, adapterContext, requestContext);
             }
             const { data: record } = recordLayoutSnapshot;
             // try to load all the requested layouts from cache
             const recordTypeId = getRecordTypeId$2(record);
             const modes = config.modes === undefined ? [DEFAULT_MODE] : config.modes;
-            return makeRecordLayoutMap(luvio, config, objectInfoSnapshot.data.apiName, recordTypeId, layoutTypes, modes).then((recordLayoutMap) => {
-                return luvio.applyCachePolicy(requestContext || {}, { config, luvio }, buildRecordLayoutSnapshot(recordLayoutMap, luvio, config, recordLayoutSnapshot, objectInfoSnapshot), buildNetworkSnapshot$V);
+            // W-12697744
+            // For non-layoutable entities, use the implicit fields as the fields are not available in layout
+            // Fields can be fetched from adapter context if the server request was already made at some point in the past
+            // If fields are not available in adapter context, make a network request to get the data
+            // and store implicit fields in adapter context.
+            if (!objectInfoSnapshot.data.layoutable) {
+                const selectorKey = buildObjectInfoSelectorKey(luvio, objectInfoSnapshot.data);
+                const fields = adapterContext.get(selectorKey);
+                if (!fields) {
+                    return makeNetworkOnlySnapshot(luvio, config, adapterContext, requestContext);
+                }
+                return luvio.applyCachePolicy(requestContext || {}, { config, luvio, adapterContext }, buildRecordSnapshot(luvio, config, recordLayoutSnapshot, objectInfoSnapshot, fields), buildNetworkSnapshot$V);
+            }
+            return makeRecordLayoutMap(luvio, config, objectInfoSnapshot.data.apiName, recordTypeId, layoutTypes, modes, adapterContext).then((recordLayoutMap) => {
+                return luvio.applyCachePolicy(requestContext || {}, { config, luvio, adapterContext }, buildRecordLayoutSnapshot(recordLayoutMap, luvio, config, recordLayoutSnapshot, objectInfoSnapshot), buildNetworkSnapshot$V);
             });
         });
     });
@@ -20045,13 +20086,13 @@ function getRecordLayoutType(luvio, config, requestContext) {
  * @param  {LayoutType[]} layoutTypes
  * @param  {LayoutMode[]} modes
  */
-function makeRecordLayoutMap(luvio, config, apiName, recordTypeId, layoutTypes, modes) {
+function makeRecordLayoutMap(luvio, config, apiName, recordTypeId, layoutTypes, modes, adapterContext) {
     let promises = [];
     for (let i = 0; i < layoutTypes.length; i++) {
         const layoutType = layoutTypes[i];
         for (let m = 0; m < modes.length; m++) {
             const mode = modes[m];
-            promises.push(Promise.resolve(makeCacheOnlySnapshot(luvio, config, buildLayoutModeCacheSnapshot(apiName, recordTypeId, layoutType, mode))).then((snapshot) => {
+            promises.push(Promise.resolve(makeCacheOnlySnapshot(luvio, config, adapterContext, buildLayoutModeCacheSnapshot(apiName, recordTypeId, layoutType, mode))).then((snapshot) => {
                 return {
                     layoutType,
                     mode,
@@ -20091,34 +20132,46 @@ function makeRecordLayoutMap(luvio, config, apiName, recordTypeId, layoutTypes,
 }
 function buildRecordLayoutSnapshot(recordLayout, luvio, config, recordLayoutSnapshot, objectInfoSnapshot) {
     return (context, storeLookup) => {
-        const { layoutMap, isStale } = recordLayout;
+        const { layoutMap, isStale: isRecordLayoutStale } = recordLayout;
         if (layoutMap === undefined || objectInfoSnapshot.data === undefined) {
             return;
         }
         // transform the layouts & object info into a set of fields
         const fields = getFieldsFromLayoutMap(layoutMap, objectInfoSnapshot.data);
-        const optionalFields = config.optionalFields === undefined ? [] : dedupe(config.optionalFields).sort();
-        const { recordId } = config;
-        // borrow GetRecordFields' logic to construct the RecordRepresentation with the necessary fields
-        const sel = buildRecordSelector(luvio, recordId, fields, optionalFields);
-        const recordRepSnapshot = storeLookup(sel, buildSnapshotRefresh$3(luvio, config));
-        if (isFulfilledSnapshot(recordRepSnapshot)) {
-            // mark snapshot as stale if any of the information used to construct it was stale
-            if (isStaleSnapshot(recordLayoutSnapshot) ||
-                isStaleSnapshot(objectInfoSnapshot) ||
-                isStale) {
-                recordRepSnapshot.state = 'Stale';
-            }
-        }
-        // allow buildNetworkSnapshot() to use GetRecordFields if we were just missing some fields in L1
-        else if (isUnfulfilledSnapshot(recordRepSnapshot)) {
-            context.fields = fields;
-        }
-        // return however much of the record we were able to find in L1; cache policy decides if we
-        // should consult L2 or go to network
-        return recordRepSnapshot;
+        return getRecordRepSnapshot(luvio, config, recordLayoutSnapshot, objectInfoSnapshot, fields, isRecordLayoutStale, context, storeLookup);
     };
 }
+function buildRecordSnapshot(luvio, config, recordLayoutSnapshot, objectInfoSnapshot, fields) {
+    return (context, storeLookup) => {
+        return getRecordRepSnapshot(luvio, config, recordLayoutSnapshot, objectInfoSnapshot, fields, false, context, storeLookup);
+    };
+}
+function getRecordRepSnapshot(luvio, config, recordLayoutSnapshot, objectInfoSnapshot, fields, isRecordLayoutStale, context, storeLookup) {
+    if (objectInfoSnapshot.data === undefined) {
+        return;
+    }
+    // transform the layouts & object info into a set of fields
+    const optionalFields = config.optionalFields === undefined ? [] : dedupe(config.optionalFields).sort();
+    const { recordId } = config;
+    // borrow GetRecordFields' logic to construct the RecordRepresentation with the necessary fields
+    const sel = buildRecordSelector(luvio, recordId, fields, optionalFields);
+    const recordRepSnapshot = storeLookup(sel, buildSnapshotRefresh$3(luvio, config));
+    if (isFulfilledSnapshot(recordRepSnapshot)) {
+        // mark snapshot as stale if any of the information used to construct it was stale
+        if (isStaleSnapshot(objectInfoSnapshot) ||
+            isStaleSnapshot(recordLayoutSnapshot) ||
+            isRecordLayoutStale) {
+            recordRepSnapshot.state = 'Stale';
+        }
+    }
+    // allow buildNetworkSnapshot() to use GetRecordFields if we were just missing some fields in L1
+    else if (isUnfulfilledSnapshot(recordRepSnapshot)) {
+        context.fields = fields;
+    }
+    // return however much of the record we were able to find in L1; cache policy decides if we
+    // should consult L2 or go to network
+    return recordRepSnapshot;
+}
 function runSnapshotOrPromise(promiseOrSnapshot, next) {
     if (isPromise(promiseOrSnapshot)) {
         return promiseOrSnapshot.then(next);
@@ -20128,6 +20181,7 @@ function runSnapshotOrPromise(promiseOrSnapshot, next) {
     }
 }
 
+const contextId$4 = `${keyPrefix}__${adapterName$5}`;
 // Custom adapter config due to `unsupported` items
 const GET_RECORD_ADAPTER_CONFIG = {
     displayName: 'getRecord',
@@ -20218,19 +20272,21 @@ const notifyChangeFactory = (luvio) => {
         });
     };
 };
-const factory$g = (luvio) => function getRecord(untrustedConfig, requestContext) {
-    // standard config validation and coercion
-    const config = validateAdapterConfig$12(untrustedConfig, GET_RECORD_ADAPTER_CONFIG);
-    if (config === null) {
+const factory$g = (luvio) => {
+    return luvio.withContext(function getRecord(untrustedConfig, adapterContext, requestContext) {
+        // standard config validation and coercion
+        const config = validateAdapterConfig$12(untrustedConfig, GET_RECORD_ADAPTER_CONFIG);
+        if (config === null) {
+            return null;
+        }
+        if (hasLayoutTypes(config)) {
+            return getRecordLayoutType(luvio, config, adapterContext, requestContext);
+        }
+        else if (hasFieldsOrOptionalFields(config)) {
+            return getRecordByFields(luvio, config, requestContext);
+        }
         return null;
-    }
-    if (hasLayoutTypes(config)) {
-        return getRecordLayoutType(luvio, config, requestContext);
-    }
-    else if (hasFieldsOrOptionalFields(config)) {
-        return getRecordByFields(luvio, config, requestContext);
-    }
-    return null;
+    }, { contextId: contextId$4 });
 };
 
 const VERSION$22 = "7e00c51105cbf56a79ab8fcddf462c1e";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lwc-adapters-uiapi",
-    "version": "1.182.0",
+    "version": "1.182.1",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "UIAPI adapters with LWC bindings",
     "module": "dist/main.js",