@salesforce/lds-ads-bridge 1.339.0 → 1.341.0

package/src/__tests__/ads-bridge.spec.ts

@@ -1,17 +1,22 @@
 import { Luvio, InMemoryStore, Environment } from '@luvio/engine';
-import { keyBuilderRecord, ingestRecord } from '@salesforce/lds-adapters-uiapi';
+import { keyBuilderRecord, ingestRecord, type Registration } from '@salesforce/lds-adapters-uiapi';
 import { expect } from '@jest/globals';
 
 import AdsBridge from '../ads-bridge';
 import { isDMOEntity } from '../ads-bridge';
 import { addObjectInfo, addRecord, createObjectInfo, createRecord } from './test-utils';
 import { instrumentation } from '../instrumentation';
+import { withRegistration } from '@salesforce/lds-default-luvio';
 
 function createBridge() {
+    withRegistration<Registration>('@salesforce/lds-adapters-uiapi', (registration) => {
+        const { configuration } = registration;
+        configuration.setRecordRepresentationIngestionOverride(undefined);
+    });
     const store = new InMemoryStore();
     const environment = new Environment(store, jest.fn());
     const luvio = new Luvio(environment);
-    const bridge = new AdsBridge(luvio);
+    const bridge = new AdsBridge(luvio, undefined);
 
     return { store, luvio, bridge };
 }

package/src/__tests__/test-utils.ts

@@ -1,5 +1,9 @@
 import { Luvio } from '@luvio/engine';
-import { ingestRecord, ingestObjectInfo } from '@salesforce/lds-adapters-uiapi';
+import {
+    getRecordIngestionOverride,
+    ingestObjectInfo,
+    ingestRecord,
+} from '@salesforce/lds-adapters-uiapi';
 
 export function createRecord(config: any = {}) {
     return {
@@ -3256,7 +3260,9 @@ export function createObjectInfo(config: any = {}) {
 }
 
 export function addRecord(luvio: Luvio, data: any) {
-    luvio.storeIngest('', ingestRecord, data);
+    const recordIngest =
+        getRecordIngestionOverride() !== undefined ? getRecordIngestionOverride() : ingestRecord;
+    luvio.storeIngest('', recordIngest!, data);
     luvio.storeBroadcast();
 }
 

package/src/ads-bridge.ts

@@ -1,15 +1,19 @@
-import type { Luvio, ProxyGraphNode, GraphNode } from '@luvio/engine';
+import type { Luvio, ProxyGraphNode, GraphNode, ResourceIngest } from '@luvio/engine';
 import type {
-    RecordRepresentation,
-    RecordRepresentationNormalized,
     ObjectInfoRepresentation,
     FieldValueRepresentation,
     FieldValueRepresentationNormalized,
+    RecordRepresentation,
+    RecordRepresentationNormalized,
 } from '@salesforce/lds-adapters-uiapi';
+import type {
+    RecordRepresentation as DenormalizedRecordRepresentation,
+    RecordRepresentationNormalized as DenormalizedRecordRepresentationNormalized,
+} from '@salesforce/lds-runtime-mobile';
 import {
-    ingestRecord,
     keyBuilderRecord,
     keyBuilderObjectInfo,
+    ingestRecord as ingestNormalizedRecordRepresentation,
 } from '@salesforce/lds-adapters-uiapi';
 
 import {
@@ -103,6 +107,82 @@ function isStoreKeyRecordId(key: string) {
     return key.indexOf(RECORD_ID_PREFIX) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION) === -1;
 }
 
+/**
+ * Returns a shallow copy of a record with its field values if it is a scalar and a reference and a
+ * a RecordRepresentation with no field if the value if a spanning record.
+ * It returns null if the record contains any pending field.
+ */
+function getShallowRecordDenormalized(
+    luvio: Luvio,
+    storeRecordId: string
+): DenormalizedRecordRepresentation | null {
+    const recordNode = luvio.getNode<
+        DenormalizedRecordRepresentationNormalized,
+        DenormalizedRecordRepresentation
+    >(storeRecordId);
+
+    if (!isGraphNode(recordNode)) {
+        return null;
+    }
+
+    const fieldsCopy: DenormalizedRecordRepresentation['fields'] = {};
+    const copy: DenormalizedRecordRepresentation = {
+        ...recordNode.retrieve(),
+        fields: fieldsCopy,
+        childRelationships: {},
+    };
+
+    const fieldsNode = recordNode.object('fields');
+    const fieldNames = fieldsNode.keys();
+
+    for (let i = 0, len = fieldNames.length; i < len; i++) {
+        let fieldCopy: FieldValueRepresentation;
+
+        const fieldName = fieldNames[i];
+        if (fieldsNode.isPending(fieldName) === true) {
+            return null;
+        }
+
+        if (fieldsNode.isMissing(fieldName) === true) {
+            continue;
+        }
+
+        const fieldObject = fieldsNode.object(fieldName);
+        const { displayValue, value } = fieldObject.retrieve();
+        if (fieldObject.isScalar('value')) {
+            fieldCopy = {
+                displayValue: displayValue,
+                value: value as string | number | boolean | null,
+            };
+        } else {
+            const spanningRecordLink = fieldObject.link<
+                DenormalizedRecordRepresentationNormalized,
+                DenormalizedRecordRepresentation
+            >('value');
+            if (spanningRecordLink.isPending() === true) {
+                return null;
+            }
+
+            const spanningRecordNode = spanningRecordLink.follow();
+            if (!isGraphNode(spanningRecordNode)) {
+                continue;
+            }
+
+            fieldCopy = {
+                displayValue,
+                value: {
+                    ...spanningRecordNode.retrieve(),
+                    fields: {},
+                    childRelationships: {},
+                },
+            };
+        }
+
+        fieldsCopy[fieldName] = fieldCopy;
+    }
+    return copy;
+}
+
 /**
  * Returns a shallow copy of a record with its field values if it is a scalar and a reference and a
  * a RecordRepresentation with no field if the value if a spanning record.
@@ -176,7 +256,6 @@ function getShallowRecord(luvio: Luvio, storeRecordId: string): RecordRepresenta
 
         fieldsCopy[fieldName] = fieldCopy;
     }
-
     return copy;
 }
 
@@ -265,7 +344,10 @@ export default class AdsBridge {
     private isRecordEmitLocked: boolean = false;
     private watchUnsubscribe: Unsubscribe | undefined;
 
-    constructor(private luvio: Luvio) {}
+    constructor(
+        private luvio: Luvio,
+        private recordRepresentationIngestOverride: ResourceIngest | undefined
+    ) {}
 
     /**
      * This setter invoked by recordLibrary to listen for records ingested by Luvio. The passed method
@@ -324,7 +406,12 @@ export default class AdsBridge {
                     // with the master record type. See W-7302870 for details.
                     fixRecordTypes(luvio, recordCopy);
 
-                    luvio.storeIngest(INGEST_KEY, ingestRecord, recordCopy);
+                    const recordIngest =
+                        this.recordRepresentationIngestOverride !== undefined
+                            ? this.recordRepresentationIngestOverride
+                            : ingestNormalizedRecordRepresentation;
+
+                    luvio.storeIngest(INGEST_KEY, recordIngest, recordCopy);
                 }
             }
 
@@ -427,7 +514,10 @@ export default class AdsBridge {
                 continue;
             }
 
-            const record = getShallowRecord(luvio, storeRecordId);
+            const record =
+                this.recordRepresentationIngestOverride !== undefined
+                    ? getShallowRecordDenormalized(luvio, storeRecordId)
+                    : getShallowRecord(luvio, storeRecordId);
             if (record === null) {
                 continue;
             }

package/src/main.ts

@@ -1,6 +1,7 @@
 import type { Luvio } from '@luvio/engine';
 import AdsBridge from './ads-bridge';
 
+import { getRecordIngestionOverride } from '@salesforce/lds-adapters-uiapi';
 import { withDefaultLuvio } from '@salesforce/lds-default-luvio';
 
 /**
@@ -16,7 +17,12 @@ let callbacks: Callback[] = [];
 
 // create a new AdsBridge whenever the default Luvio is set/changed
 withDefaultLuvio((luvio: Luvio) => {
-    adsBridge = new AdsBridge(luvio);
+    /**
+     * Cache the current value of ingestion override on startup.
+     * This needs be set prior to loading of the ADS bridge.
+     */
+    const recordIngestionOverride = getRecordIngestionOverride();
+    adsBridge = new AdsBridge(luvio, recordIngestionOverride);
 
     for (let i = 0; i < callbacks.length; ++i) {
         callbacks[i](adsBridge);