@salesforce/lds-ads-bridge 1.100.2

package/dist/ads-bridge.d.ts

@@ -0,0 +1,87 @@
+import type { Luvio } from '@luvio/engine';
+import type { RecordRepresentation } from '@salesforce/lds-adapters-uiapi';
+interface AdsRecord {
+    /**
+     * True if the passed record is a primary record, otherwise false.
+     *
+     * The Salesforce APIs may represent different records with the same record id. All the
+     * records returned by the UI API are primary records.
+     */
+    isPrimary: boolean;
+    /** The actual record data */
+    record: RecordRepresentation;
+}
+interface AdsRecordMap {
+    [recordId: string]: {
+        [objectApiName: string]: AdsRecord;
+    };
+}
+interface ObjectMetadata {
+    /**
+     * The entity key prefix.
+     * This originally was typed as simply a "string",
+     * however, "keyPrefix" can be null on ObjectInfoRepresentation
+     * and existing behavior simply passes ObjectInfoRepresentation.keyPrefix
+     * straight to ADS. This type has been updated to capture that
+     * a string or null can be passed here.
+     * */
+    _keyPrefix: string | null;
+    /** The entity field name. */
+    _nameField: string;
+    /** The entity label. */
+    _entityLabel: string;
+}
+interface AdsObjectMetadataMap {
+    [objectApiName: string]: ObjectMetadata;
+}
+type LdsRecordChangedCallback = (record: AdsRecordMap, objectMetadata: AdsObjectMetadataMap) => any;
+/**
+ * Returns whether or not a the record is a DMO entity.
+ * @param record - The record.
+ * @returns True if DMO, false otherwise.
+ */
+export declare function isDMOEntity(record: RecordRepresentation): boolean;
+export default class AdsBridge {
+    private luvio;
+    private isRecordEmitLocked;
+    private watchUnsubscribe;
+    constructor(luvio: Luvio);
+    /**
+     * This setter invoked by recordLibrary to listen for records ingested by Luvio. The passed method
+     * is invoked whenever a record is ingested. It may be via getRecord, getRecordUi, getListUi, ...
+     */
+    set receiveFromLdsCallback(callback: LdsRecordChangedCallback | undefined);
+    /**
+     * This method is invoked when a record has been ingested by ADS.
+     *
+     * ADS may invoke this method with records that are not UIAPI allowlisted so not refreshable by
+     * Luvio. Luvio filters the provided list so it ingests only UIAPI allowlisted records.
+     */
+    addRecords(records: RecordRepresentation[], uiApiEntityAllowlist?: {
+        [name: string]: 'false' | undefined;
+    }): void;
+    /**
+     * This method is invoked whenever a record has been evicted from ADS.
+     */
+    evict(recordId: string): Promise<void>;
+    /**
+     * Gets the list of fields of a record that Luvio has in its store. The field list doesn't
+     * contains the spanning record fields. ADS uses this list when it loads a record from the
+     * server. This is an optimization to make a single roundtrip it queries for all fields required
+     * by ADS and Luvio.
+     */
+    getTrackedFieldsForRecord(recordId: string): Promise<string[]>;
+    /**
+     * Prevents the bridge to emit record change during the execution of the callback.
+     * This methods should wrap all the Luvio store mutation done by the bridge. It prevents Luvio store
+     * mutations triggered by ADS to be emit back to ADS.
+     */
+    private lockLdsRecordEmit;
+    /**
+     * This method retrieves queries the store with with passed record ids to retrieve their
+     * associated records and object info. Note that the passed ids are not Salesforce record id
+     * but rather Luvio internals store ids.
+     */
+    private emitRecordChanged;
+}
+export {};

package/dist/adsBridge.js

@@ -0,0 +1,378 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/*  *******************************************************************************************
+ *  ATTENTION!
+ *  THIS IS A GENERATED FILE FROM https://github.com/salesforce-experience-platform-emu/lds-lightning-platform
+ *  If you would like to contribute to LDS, please follow the steps outlined in the git repo.
+ *  Any changes made to this file in p4 will be automatically overwritten.
+ *  *******************************************************************************************
+ */
+/* proxy-compat-disable */
+import { ingestRecord, keyBuilderRecord, keyBuilderObjectInfo } from 'force/ldsAdaptersUiapi';
+import { withDefaultLuvio } from 'force/ldsEngine';
+
+const { push } = Array.prototype;
+const { keys } = Object;
+const { hasOwnProperty } = Object.prototype;
+const { parse, stringify } = JSON;
+
+const ADS_BRIDGE_ADD_RECORDS_DURATION = 'ads-bridge-add-records-duration';
+const ADS_BRIDGE_EMIT_RECORD_CHANGED_DURATION = 'ads-bridge-emit-record-changed-duration';
+const ADS_BRIDGE_EVICT_DURATION = 'ads-bridge-evict-duration';
+
+// For use by callers within this module to instrument interesting things.
+let instrumentation = {
+    timerMetricAddDuration: (_metricName, _valueInMs) => { },
+};
+/**
+ * Allows external modules (typically a runtime environment) to set
+ * instrumentation hooks for this module. Note that the hooks are
+ * incremental - hooks not suppiled in newInstrumentation will retain
+ * their previous values. The default instrumentation hooks are no-ops.
+ *
+ * @param newInstrumentation instrumentation hooks to be overridden
+ */
+function instrument(newInstrumentation) {
+    instrumentation = Object.assign(instrumentation, newInstrumentation);
+}
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+const API_NAMESPACE = 'UiApi';
+const RECORD_REPRESENTATION_NAME = 'RecordRepresentation';
+const RECORD_ID_PREFIX = `${API_NAMESPACE}::${RECORD_REPRESENTATION_NAME}:`;
+const RECORD_FIELDS_KEY_JUNCTION = '__fields__';
+function isStoreKeyRecordId(key) {
+    return key.indexOf(RECORD_ID_PREFIX) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION) === -1;
+}
+
+// No need to pass the actual record key `luvio.ingestStore`. The `RecordRepresentation.ts#ingest`
+// function extracts the appropriate record id from the ingested record.
+const INGEST_KEY = '';
+const MASTER_RECORD_TYPE_ID = '012000000000000AAA';
+const DMO_API_NAME_SUFFIX = '__dlm';
+function isGraphNode(node) {
+    return node !== null && node.type === 'Node';
+}
+function isSpanningRecord(fieldValue) {
+    return fieldValue !== null && typeof fieldValue === 'object';
+}
+/**
+ * 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 getShallowRecord(luvio, storeRecordId) {
+    const recordNode = luvio.getNode(storeRecordId);
+    if (!isGraphNode(recordNode)) {
+        return null;
+    }
+    const fieldsCopy = {};
+    const copy = {
+        ...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;
+        const fieldName = fieldNames[i];
+        const fieldLink = fieldsNode.link(fieldName);
+        if (fieldLink.isPending() === true) {
+            return null;
+        }
+        const fieldNode = fieldLink.follow();
+        if (!isGraphNode(fieldNode)) {
+            continue;
+        }
+        const { displayValue, value } = fieldNode.retrieve();
+        if (fieldNode.isScalar('value')) {
+            fieldCopy = {
+                displayValue: displayValue,
+                value: value,
+            };
+        }
+        else {
+            const spanningRecordLink = fieldNode.link('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 the ADS object metadata representation for a specific record.
+ */
+function getObjectMetadata(luvio, record) {
+    const { data: objectInfo } = luvio.storeLookup({
+        recordId: keyBuilderObjectInfo(luvio, { apiName: record.apiName }),
+        node: {
+            kind: 'Fragment',
+            private: ['eTag'],
+            opaque: true,
+        },
+        variables: {},
+    });
+    if (objectInfo !== undefined) {
+        let nameField = 'Name';
+        // Extract the entity name field from the object info. In the case where there are multiple
+        // field names then pick up the first one.
+        if (objectInfo.nameFields.length !== 0 && objectInfo.nameFields.indexOf('Name') === -1) {
+            nameField = objectInfo.nameFields[0];
+        }
+        return {
+            _nameField: nameField,
+            _entityLabel: objectInfo.label,
+            _keyPrefix: objectInfo.keyPrefix,
+        };
+    }
+    return {
+        _nameField: 'Name',
+        _entityLabel: record.apiName,
+        _keyPrefix: record.id.substring(0, 3),
+    };
+}
+/**
+ * RecordGvp can send records back to ADS with record types incorrectly set to the master
+ * record type. Since there are no known legitimate scenarios where a record can change from a
+ * non-master record type back to the master record type, we assume such a transition
+ * indicates a RecordGvp mistake. This function checks for that scenario and overwrites the
+ * incoming ADS record type information with what we already have in the store when it
+ * occurs.
+ *
+ * @param luvio Luvio
+ * @param record record from ADS, will be fixed in situ
+ */
+function fixRecordTypes(luvio, record) {
+    // non-master record types should always be correct
+    if (record.recordTypeId === MASTER_RECORD_TYPE_ID) {
+        const key = keyBuilderRecord(luvio, { recordId: record.id });
+        const recordNode = luvio.getNode(key);
+        if (isGraphNode(recordNode) &&
+            recordNode.scalar('recordTypeId') !== MASTER_RECORD_TYPE_ID) {
+            // ignore bogus incoming record type information & keep what we have
+            record.recordTypeId = recordNode.scalar('recordTypeId');
+            record.recordTypeInfo = recordNode.object('recordTypeInfo').data;
+        }
+    }
+    // recurse on nested records
+    const fieldKeys = keys(record.fields);
+    const fieldKeysLen = fieldKeys.length;
+    for (let i = 0; i < fieldKeysLen; ++i) {
+        const fieldValue = record.fields[fieldKeys[i]].value;
+        if (isSpanningRecord(fieldValue)) {
+            fixRecordTypes(luvio, fieldValue);
+        }
+    }
+}
+/**
+ * Returns whether or not a the record is a DMO entity.
+ * @param record - The record.
+ * @returns True if DMO, false otherwise.
+ */
+function isDMOEntity(record) {
+    return record.apiName.endsWith(DMO_API_NAME_SUFFIX);
+}
+class AdsBridge {
+    constructor(luvio) {
+        this.luvio = luvio;
+        this.isRecordEmitLocked = false;
+    }
+    /**
+     * This setter invoked by recordLibrary to listen for records ingested by Luvio. The passed method
+     * is invoked whenever a record is ingested. It may be via getRecord, getRecordUi, getListUi, ...
+     */
+    set receiveFromLdsCallback(callback) {
+        // Unsubscribe if there is an existing subscription.
+        if (this.watchUnsubscribe !== undefined) {
+            this.watchUnsubscribe();
+            this.watchUnsubscribe = undefined;
+        }
+        if (callback !== undefined) {
+            this.watchUnsubscribe = this.luvio.storeWatch(RECORD_ID_PREFIX, (entries) => {
+                if (this.isRecordEmitLocked === true) {
+                    return;
+                }
+                this.emitRecordChanged(entries, callback);
+            });
+        }
+    }
+    /**
+     * This method is invoked when a record has been ingested by ADS.
+     *
+     * ADS may invoke this method with records that are not UIAPI allowlisted so not refreshable by
+     * Luvio. Luvio filters the provided list so it ingests only UIAPI allowlisted records.
+     */
+    addRecords(records, uiApiEntityAllowlist) {
+        const startTime = Date.now();
+        const { luvio } = this;
+        let didIngestRecord = false;
+        return this.lockLdsRecordEmit(() => {
+            for (let i = 0; i < records.length; i++) {
+                const record = records[i];
+                const { apiName } = record;
+                // Ingest the record if no allowlist is passed or the entity name is allowlisted.
+                if (uiApiEntityAllowlist === undefined ||
+                    uiApiEntityAllowlist[apiName] !== 'false') {
+                    didIngestRecord = true;
+                    // Deep-copy the record to ingest and ingest the record copy. This avoids
+                    // corrupting the ADS cache since ingestion mutates the passed record.
+                    const recordCopy = parse(stringify(record));
+                    // Don't let incorrect ADS/RecordGVP recordTypeIds replace a valid record type in our store
+                    // with the master record type. See W-7302870 for details.
+                    fixRecordTypes(luvio, recordCopy);
+                    luvio.storeIngest(INGEST_KEY, ingestRecord, recordCopy);
+                }
+            }
+            if (didIngestRecord === true) {
+                luvio.storeBroadcast();
+            }
+            instrumentation.timerMetricAddDuration(ADS_BRIDGE_ADD_RECORDS_DURATION, Date.now() - startTime);
+        });
+    }
+    /**
+     * This method is invoked whenever a record has been evicted from ADS.
+     */
+    evict(recordId) {
+        const startTime = Date.now();
+        const { luvio } = this;
+        const key = keyBuilderRecord(luvio, { recordId });
+        return this.lockLdsRecordEmit(() => {
+            luvio.storeEvict(key);
+            luvio.storeBroadcast();
+            instrumentation.timerMetricAddDuration(ADS_BRIDGE_EVICT_DURATION, Date.now() - startTime);
+            return Promise.resolve();
+        });
+    }
+    /**
+     * Gets the list of fields of a record that Luvio has in its store. The field list doesn't
+     * contains the spanning record fields. ADS uses this list when it loads a record from the
+     * server. This is an optimization to make a single roundtrip it queries for all fields required
+     * by ADS and Luvio.
+     */
+    getTrackedFieldsForRecord(recordId) {
+        const { luvio } = this;
+        const storeRecordId = keyBuilderRecord(luvio, { recordId });
+        const recordNode = luvio.getNode(storeRecordId);
+        if (!isGraphNode(recordNode)) {
+            return Promise.resolve([]);
+        }
+        const apiName = recordNode.scalar('apiName');
+        const fieldNames = recordNode.object('fields').keys();
+        // Prefix all the fields with the record API name.
+        const qualifiedFieldNames = [];
+        for (let i = 0, len = fieldNames.length; i < len; i++) {
+            push.call(qualifiedFieldNames, `${apiName}.${fieldNames[i]}`);
+        }
+        return Promise.resolve(qualifiedFieldNames);
+    }
+    /**
+     * Prevents the bridge to emit record change during the execution of the callback.
+     * This methods should wrap all the Luvio store mutation done by the bridge. It prevents Luvio store
+     * mutations triggered by ADS to be emit back to ADS.
+     */
+    lockLdsRecordEmit(callback) {
+        this.isRecordEmitLocked = true;
+        try {
+            return callback();
+        }
+        finally {
+            this.isRecordEmitLocked = false;
+        }
+    }
+    /**
+     * This method retrieves queries the store with with passed record ids to retrieve their
+     * associated records and object info. Note that the passed ids are not Salesforce record id
+     * but rather Luvio internals store ids.
+     */
+    emitRecordChanged(updatedEntries, callback) {
+        const startTime = Date.now();
+        const { luvio } = this;
+        let shouldEmit = false;
+        const adsRecordMap = {};
+        const adsObjectMap = {};
+        for (let i = 0; i < updatedEntries.length; i++) {
+            const storeRecordId = updatedEntries[i].id;
+            // Exclude all the store record ids not matching with the record id pattern.
+            // Note: FieldValueRepresentation have the same prefix than RecordRepresentation so we
+            // need to filter them out.
+            if (!isStoreKeyRecordId(storeRecordId)) {
+                continue;
+            }
+            const record = getShallowRecord(luvio, storeRecordId);
+            if (record === null) {
+                continue;
+            }
+            // W-9978523
+            if (isDMOEntity(record) === true) {
+                continue;
+            }
+            const { id, apiName } = record;
+            shouldEmit = true;
+            adsRecordMap[id] = {
+                [apiName]: {
+                    isPrimary: true,
+                    record,
+                },
+            };
+            // Extract and add the object metadata to the map if not already present.
+            if (!hasOwnProperty.call(adsObjectMap, apiName)) {
+                adsObjectMap[apiName] = getObjectMetadata(luvio, record);
+            }
+        }
+        if (shouldEmit === true) {
+            callback(adsRecordMap, adsObjectMap);
+        }
+        instrumentation.timerMetricAddDuration(ADS_BRIDGE_EMIT_RECORD_CHANGED_DURATION, Date.now() - startTime);
+    }
+}
+
+// most recently created AdsBridge
+let adsBridge;
+// callbacks to be invoked when AdsBridge is set/changed
+let callbacks = [];
+// create a new AdsBridge whenever the default Luvio is set/changed
+withDefaultLuvio((luvio) => {
+    adsBridge = new AdsBridge(luvio);
+    for (let i = 0; i < callbacks.length; ++i) {
+        callbacks[i](adsBridge);
+    }
+});
+/**
+ * Registers a callback to be invoked with the AdsBridge instance. Note that the
+ * callback may be invoked multiple times if the default Luvio changes.
+ *
+ * @param callback callback to be invoked with the AdsBridge
+ */
+function withAdsBridge(callback) {
+    if (adsBridge) {
+        callback(adsBridge);
+    }
+    callbacks.push(callback);
+}
+
+export { instrument, withAdsBridge };
+// version: 1.100.2-ca56bb821

package/dist/instrumentation.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Instrumentation hooks exposed by this module.
+ */
+export interface AdsBridgeInstrumentation {
+    /**
+     * Called at the end of execution for a function to track latency
+     * Current functions tracked: packages/lds-ads-bridge/src/utils/metric-keys.ts
+     */
+    timerMetricAddDuration?: (metricName: string, valueInMs: number) => void;
+}
+export declare let instrumentation: {
+    timerMetricAddDuration: (_metricName: string, _valueInMs: number) => void;
+};
+/**
+ * Allows external modules (typically a runtime environment) to set
+ * instrumentation hooks for this module. Note that the hooks are
+ * incremental - hooks not suppiled in newInstrumentation will retain
+ * their previous values. The default instrumentation hooks are no-ops.
+ *
+ * @param newInstrumentation instrumentation hooks to be overridden
+ */
+export declare function instrument(newInstrumentation: AdsBridgeInstrumentation): void;

package/dist/main.d.ts

@@ -0,0 +1,13 @@
+import AdsBridge from './ads-bridge';
+/**
+ * Callback used to inform interested parties that a new default Luvio has been set.
+ */
+export type Callback = (adsBridge: AdsBridge) => void;
+/**
+ * Registers a callback to be invoked with the AdsBridge instance. Note that the
+ * callback may be invoked multiple times if the default Luvio changes.
+ *
+ * @param callback callback to be invoked with the AdsBridge
+ */
+export declare function withAdsBridge(callback: Callback): void;
+export { instrument, AdsBridgeInstrumentation } from './instrumentation';

package/dist/utils/language.d.ts

@@ -0,0 +1,11 @@
+declare const push: (...items: any[]) => number;
+declare const keys: {
+    (o: object): string[];
+    (o: {}): string[];
+};
+declare const hasOwnProperty: (v: PropertyKey) => boolean;
+declare const parse: (text: string, reviver?: ((this: any, key: string, value: any) => any) | undefined) => any, stringify: {
+    (value: any, replacer?: ((this: any, key: string, value: any) => any) | undefined, space?: string | number | undefined): string;
+    (value: any, replacer?: (string | number)[] | null | undefined, space?: string | number | undefined): string;
+};
+export { push as ArrayPrototypePush, keys as ObjectKeys, hasOwnProperty as ObjectPrototypeHasOwnProperty, parse as JSONParse, stringify as JSONStringify, };

package/dist/utils/metric-keys.d.ts

@@ -0,0 +1,3 @@
+export declare const ADS_BRIDGE_ADD_RECORDS_DURATION = "ads-bridge-add-records-duration";
+export declare const ADS_BRIDGE_EMIT_RECORD_CHANGED_DURATION = "ads-bridge-emit-record-changed-duration";
+export declare const ADS_BRIDGE_EVICT_DURATION = "ads-bridge-evict-duration";

package/jest.config.js

@@ -0,0 +1,8 @@
+const baseConfig = require('../../scripts/jest/base.config');
+
+module.exports = {
+    ...baseConfig,
+
+    displayName: '@salesforce/lds-ads-bridge',
+    roots: ['<rootDir>/src'],
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "@salesforce/lds-ads-bridge",
+    "version": "1.100.2",
+    "license": "SEE LICENSE IN LICENSE.txt",
+    "description": "Bridge to sync data between LDS and ADS",
+    "main": "dist/adsBridge.js",
+    "module": "dist/adsBridge.js",
+    "types": "dist/main.d.ts",
+    "sfdc": {
+        "path": "forcelds/adsBridge/",
+        "publishedFileName": "adsBridge.js",
+        "overrides": {
+            "artifactDirectory": "dist",
+            "outputModuleName": "adsBridge"
+        }
+    },
+    "scripts": {
+        "prepare": "yarn build",
+        "build": "rollup --config rollup.config.js",
+        "clean": "rm -rf dist",
+        "test:perf": "best",
+        "test:unit": "jest",
+        "test:unit:debug": "node --inspect-brk ../../node_modules/.bin/jest --runInBand",
+        "release:corejar": "yarn build && ../core-build/scripts/core.js --name=lds-ads-bridge"
+    },
+    "devDependencies": {
+        "@salesforce/lds-adapters-uiapi": "^1.100.2",
+        "@salesforce/lds-uiapi-record-utils": "^1.100.2"
+    }
+}

package/rollup.config.js

@@ -0,0 +1,47 @@
+import resolve from '@rollup/plugin-node-resolve';
+import typescript from 'rollup-plugin-typescript2';
+
+import * as packageJson from './package.json';
+import { buildBanner, buildFooter, copyrightHeaderPlugin } from '../../scripts/rollup/rollup-utils';
+
+const banner = buildBanner(true);
+const footer = buildFooter(packageJson.version);
+
+const adsBridge = {
+    input: './src/main.ts',
+    external: ['@salesforce/lds-adapters-uiapi', '@salesforce/lds-default-luvio'],
+    output: {
+        file: 'dist/adsBridge.js',
+        format: 'esm',
+        banner,
+        footer,
+        paths: {
+            '@salesforce/lds-default-luvio': 'force/ldsEngine',
+            '@salesforce/lds-adapters-uiapi': 'force/ldsAdaptersUiapi',
+        },
+    },
+    plugins: [
+        copyrightHeaderPlugin,
+        resolve(),
+        typescript({
+            clean: true,
+        }),
+    ],
+};
+
+const adsBridgeForPerfTest = {
+    input: './src/ads-bridge.ts',
+    output: {
+        file: 'dist/ads-bridge-perf.js',
+        format: 'esm',
+    },
+    plugins: [
+        copyrightHeaderPlugin,
+        resolve(),
+        typescript({
+            clean: true,
+        }),
+    ],
+};
+
+export default [adsBridge, adsBridgeForPerfTest];

package/src/__benchmarks__/ads-bridge.benchmark.js

@@ -0,0 +1,83 @@
+import { Luvio, InMemoryStore, Environment } from '@luvio/engine';
+import AdsBridge from '../../dist/ads-bridge-perf';
+import { ingestRecord, ingestObjectInfo } from '@salesforce/lds-adapters-uiapi';
+
+import mockObjectInfo from './mocks/custom-proto-medium-object-info';
+import mockRecord from './mocks/custom-proto-medium-record';
+
+function cloneObjectInfo(data) {
+    return JSON.parse(data);
+}
+
+function cloneRecord(data) {
+    const copy = JSON.parse(data);
+    copy.id = `aJ9x00000000001CA0`;
+
+    Object.keys(copy.fields).forEach((key, index) => {
+        const field = copy.fields[key];
+        if (field.value && field.value.id) {
+            field.value.id = `aJ9x00000000001C0${index}`;
+        }
+    });
+
+    return copy;
+}
+
+describe('Luvio to ADS bridge', () => {
+    benchmark('emitting single record without object info', () => {
+        let luvio;
+        let adsBridge;
+        before(() => {
+            const store = new InMemoryStore();
+            luvio = new Luvio(new Environment(store, () => new Promise(() => {})));
+            adsBridge = new AdsBridge(luvio);
+            const time = Date.now();
+
+            ingestRecord(
+                cloneRecord(mockRecord),
+                { fullPath: 'record', parent: null },
+                luvio,
+                store,
+                time
+            );
+
+            adsBridge.receiveFromLdsCallback = () => {};
+        });
+
+        run(() => {
+            luvio.storeBroadcast();
+        });
+    });
+
+    benchmark('emitting single record with object info', () => {
+        let luvio;
+        let adsBridge;
+        before(() => {
+            const store = new InMemoryStore();
+            luvio = new Luvio(new Environment(store, () => new Promise(() => {})));
+            adsBridge = new AdsBridge(luvio);
+            const time = Date.now();
+
+            ingestObjectInfo(
+                cloneObjectInfo(mockObjectInfo),
+                { fullPath: 'object-info', parent: null },
+                luvio,
+                store,
+                time
+            );
+            ingestRecord(
+                cloneRecord(mockRecord),
+                { fullPath: 'record', parent: null },
+                luvio,
+                store,
+                time
+            );
+
+            adsBridge.receiveFromLdsCallback = () => {};
+        });
+
+        run(() => {
+            luvio.storeBroadcast();
+        });
+    });
+});