@salesforce/lds-worker-api 1.228.1 → 1.229.0-dev10

package/dist/standalone/umd/lds-worker-api.js

@@ -31,12 +31,15 @@
     const { isArray: isArray$9 } = Array;
     const { push: push$5, indexOf, slice: slice$2 } = Array.prototype;
     const { parse: parse$a, stringify: stringify$a } = JSON;
+    const WeakSetCtor = WeakSet;
 
+    const deeplyFrozen = new WeakSetCtor();
     function deepFreeze(value) {
-        // No need to freeze primitives
-        if (typeof value !== 'object' || value === null) {
+        // No need to freeze primitives or already frozen stuff
+        if (typeof value !== 'object' || value === null || deeplyFrozen.has(value)) {
             return;
         }
+        deeplyFrozen.add(value);
         if (isArray$9(value)) {
             for (let i = 0, len = value.length; i < len; i += 1) {
                 deepFreeze(value[i]);
@@ -1733,6 +1736,10 @@
             }
         }
         markVisited(canonicalKey) {
+            if (typeof canonicalKey === 'string') {
+                this.fallbackStringKeyInMemoryStore.markVisited(canonicalKey);
+                return;
+            }
             const { visitedIdsSet, reverseRedirectKeysMap } = this;
             let redirectKey = canonicalKey;
             // mark all redirects leading up to the canonical key as visited so
@@ -2044,7 +2051,7 @@
             if (isStoreRecordError$1(linked)) {
                 return new GraphNodeError(this.store, linked);
             }
-            return new GraphNode(this.store, linked);
+            return new GraphNode(this.store, linked, __ref);
         }
         linkData() {
             return this.data.data;
@@ -2054,10 +2061,11 @@
         }
     }
     class GraphNode {
-        constructor(store, data) {
+        constructor(store, data, storeKey) {
             this.type = GraphNodeType$1.Node;
             this.store = store;
             this.data = data;
+            this.storeKey = storeKey;
         }
         object(propertyName) {
             const value = this.data[propertyName];
@@ -2067,7 +2075,8 @@
             if (typeof value !== 'object' || value === null) {
                 throw new Error(`Cannot walk to path ${String(propertyName)}. "${String(propertyName)}" is a scalar: "${value}"`);
             }
-            return new GraphNode(this.store, value);
+            // We're walking to an object property on the current store record, pass the storeKey down.
+            return new GraphNode(this.store, value, this.storeKey);
         }
         link(propertyName) {
             const value = this.data[propertyName];
@@ -2097,6 +2106,8 @@
         }
         write(propertyName, value) {
             this.data[propertyName] = value;
+            const canonicalKey = this.store.getCanonicalRecordId(this.storeKey);
+            this.store.markVisited(canonicalKey);
         }
         isUndefined(propertyName) {
             return this.data[propertyName] === undefined;
@@ -2281,6 +2292,34 @@
     const FRAGMENT_READ_RESULT_MISSING = {
         state: FragmentReadResultState$1.Missing,
     };
+    function resolveLink$1(reader, storeLink, version) {
+        const { StoreLinkStateValues } = reader;
+        const linkState = reader.getLinkState(storeLink);
+        switch (linkState.state) {
+            case StoreLinkStateValues.RefNotPresent:
+            case StoreLinkStateValues.NotPresent:
+            case StoreLinkStateValues.Missing:
+                reader.markMissingLink(storeLink.__ref);
+                reader.markMissing();
+                return;
+            case StoreLinkStateValues.Pending:
+                reader.markPending();
+                return;
+            case StoreLinkStateValues.Null:
+                return;
+        }
+        const { key: __ref } = linkState;
+        return reader.read({
+            recordId: __ref,
+            node: {
+                kind: 'Fragment',
+                private: [],
+                opaque: true,
+                version,
+            },
+            variables: {},
+        });
+    }
     class Reader {
         constructor(store, variables, refresh, baseSnapshot, ttlStrategy) {
             this.store = store;
@@ -3231,9 +3270,9 @@
             if (value === undefined) {
                 return null;
             }
-            return this.wrapNormalizedGraphNode(value, store);
+            return this.wrapNormalizedGraphNode(value, key, store);
         }
-        wrapNormalizedGraphNode(normalized, storeOverride) {
+        wrapNormalizedGraphNode(normalized, key, storeOverride) {
             if (normalized === null) {
                 return null;
             }
@@ -3241,7 +3280,7 @@
             if (isStoreRecordError$1(normalized)) {
                 return new GraphNodeError(store, normalized);
             }
-            return new GraphNode(store, normalized);
+            return new GraphNode(store, normalized, key);
         }
         withContext(adapter, options) {
             const { contextId, onContextLoaded } = options;
@@ -3536,8 +3575,8 @@
         getNode(key) {
             return this.environment.getNode(key);
         }
-        wrapNormalizedGraphNode(normalized) {
-            return this.environment.wrapNormalizedGraphNode(normalized);
+        wrapNormalizedGraphNode(normalized, key) {
+            return this.environment.wrapNormalizedGraphNode(normalized, key);
         }
         instrument(paramsBuilder) {
             const { instrument } = this.options;
@@ -3847,7 +3886,7 @@
         }
         return resourceParams;
     }
-    // engine version: 0.145.2-6a13677c
+    // engine version: 0.146.0-dev5-a2ec6e3f
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -3974,7 +4013,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.228.1-4e6356f71
+    // version: 1.229.0-dev10-bc9ef2513
 
     // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
     function instrumentAdapter$1(createFunction, _metadata) {
@@ -15435,7 +15474,7 @@
         }
         return superResult;
     }
-    // version: 1.228.1-4e6356f71
+    // version: 1.229.0-dev10-bc9ef2513
 
     function unwrap(data) {
         // The lwc-luvio bindings import a function from lwc called "unwrap".
@@ -15536,14 +15575,15 @@
             return undefined;
         });
     }
-    const { isArray: isArray$8 } = Array;
-    const { stringify: stringify$9 } = JSON;
 
     function isPromise$1(value) {
         // check for Thenable due to test frameworks using custom Promise impls
         return value.then !== undefined;
     }
 
+    const { isArray: isArray$8 } = Array;
+    const { stringify: stringify$9 } = JSON;
+
     /**
      * (Re)throws an error after adding a prefix to the message.
      *
@@ -16358,7 +16398,7 @@
         const { apiFamily, name } = metadata;
         return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
     }
-    // version: 1.228.1-4e6356f71
+    // version: 1.229.0-dev10-bc9ef2513
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -16457,11 +16497,11 @@
         TypeCheckShapes[TypeCheckShapes["Integer"] = 3] = "Integer";
         TypeCheckShapes[TypeCheckShapes["Unsupported"] = 4] = "Unsupported";
     })(TypeCheckShapes || (TypeCheckShapes = {}));
-    // engine version: 0.145.2-6a13677c
+    // engine version: 0.146.0-dev5-a2ec6e3f
 
     const { keys: ObjectKeys$3, create: ObjectCreate$3 } = Object;
 
-    const { assign: assign$9, create: create$9, freeze: freeze$4, keys: keys$b } = Object;
+    const { assign: assign$9, create: create$9, freeze: freeze$4, isFrozen: isFrozen$2, keys: keys$b } = Object;
 
     ObjectCreate$3(null);
 
@@ -16831,7 +16871,7 @@
     }
     const keyPrefix$1 = 'UiApi';
 
-    const { assign: assign$8, create: create$8, freeze: freeze$3, keys: keys$a } = Object;
+    const { assign: assign$8, create: create$8, freeze: freeze$3, isFrozen: isFrozen$1, keys: keys$a } = Object;
     const { hasOwnProperty: hasOwnProperty$1 } = Object.prototype;
     const { split, endsWith } = String.prototype;
     const { isArray: isArray$7 } = Array;
@@ -19800,7 +19840,7 @@
                     extractTrackedFieldsToTrie(spanningLink.data.__ref, spanning, next, config, spanningVisitedRecordIds, depth + 1);
                     // For a spanning record that is detected to be a circular reference, we add the field along with Id and Name.
                     // It's possible for spanning record lookup fields to sometimes be circular, and sometimes not - depending on the value of the lookup field.
-                    // For more information on scenarios that caused this fix: https://salesforce.quip.com/OvzNAh3eNIWY
+                    // For more information on scenarios that caused this fix: search "LDS Recursive Spanning Fields Problem" in Quip
                     if (keys$a(next.children).length === 0) {
                         addScalarFieldId(next);
                         addScalarFieldName(next);
@@ -19953,7 +19993,11 @@
         }
         const link = fieldValueRepresentation.link(fieldName);
         const resolved = link.follow();
-        if (isGraphNode(resolved) && resolved.isScalar('value') && path.length > 0) {
+        if (isGraphNode(resolved) &&
+            resolved.isScalar('value') &&
+            path.length > 0 &&
+            // TODO [W-14082782]: temporary fix
+            !isFrozen$1(link.data)) {
             const linkState = link.linkData();
             const fields = linkState === undefined ? [] : linkState.fields;
             link.writeLinkData({
@@ -19981,22 +20025,12 @@
         const fieldValueRepresentation = record.object('fields');
         const fieldName = path.shift();
         if (fieldValueRepresentation.isUndefined(fieldName) === true) {
-            // TODO [W-6900046]: remove cast, make RecordRepresentationNormalized['fields'] accept
-            // an undefined/non-present __ref if isMissing is present
-            fieldValueRepresentation.write(fieldName, {
-                __ref: undefined,
-                isMissing: true,
-            });
+            writeMissingFieldToStore(fieldValueRepresentation, fieldName);
             return;
         }
         const link = fieldValueRepresentation.link(fieldName);
         if (link.isPending()) {
-            // TODO [W-6900046]: remove cast, make RecordRepresentationNormalized['fields'] accept
-            // an undefined/non-present __ref if isMissing is present
-            fieldValueRepresentation.write(fieldName, {
-                __ref: undefined,
-                isMissing: true,
-            });
+            writeMissingFieldToStore(fieldValueRepresentation, fieldName);
         }
         else if (path.length > 0 && link.isMissing() === false) {
             const fieldValue = link.follow();
@@ -20012,6 +20046,19 @@
             }
         }
     }
+    /**
+     * Graph Node Directly modifies store entries, which is generally a non-starter.
+     * Until we can refactor this mess, you need to use this function to safely mark the RecordRepresentation
+     * as a seenId in the store when you perform this mutation.
+     */
+    function writeMissingFieldToStore(field, fieldName) {
+        // TODO [W-6900046]: remove cast, make RecordRepresentationNormalized['fields'] accept
+        // an undefined/non-present __ref if isMissing is present
+        field.write(fieldName, {
+            __ref: undefined,
+            isMissing: true,
+        });
+    }
     /**
      * Tells you if an objectApiName is supported by UI API or not.
      * Note: Luvio does not currently support all the entities, the list is limited to UI API supported entities
@@ -20143,8 +20190,11 @@
         return existing;
     }
     function mergeRecordConflict(luvio, incoming, existing, recordConflictMap) {
-        const incomingNode = luvio.wrapNormalizedGraphNode(incoming);
-        const existingNode = luvio.wrapNormalizedGraphNode(existing);
+        const recordKey = keyBuilder$1U(luvio, {
+            recordId: incoming.id,
+        });
+        const incomingNode = luvio.wrapNormalizedGraphNode(incoming, recordKey);
+        const existingNode = luvio.wrapNormalizedGraphNode(existing, recordKey);
         const incomingTrackedFieldsTrieRoot = {
             name: incoming.apiName,
             children: {},
@@ -20153,9 +20203,6 @@
             name: existing.apiName,
             children: {},
         };
-        const recordKey = keyBuilder$1U(luvio, {
-            recordId: incoming.id,
-        });
         const trackedFieldsConfig = {
             maxDepth: configurationForRestAdapters$1.getTrackedFieldDepthOnCacheMergeConflict(),
             onlyFetchLeafNodeIdAndName: configurationForRestAdapters$1.getTrackedFieldLeafNodeIdAndNameOnly(),
@@ -20461,7 +20508,7 @@
             const batchRequestWithSingleRequest = isSingleBatchRecordRequest(existingUrlParams) &&
                 isSingleRecordRequest(urlParams) &&
                 incomingUrlRecords[0] === existingUrlRecords[0];
-            if (!batchRequestWithSingleRequest) {
+            if (!batchRequestWithSingleRequest || isRestrictedPathCondition(existingPath, path)) {
                 return false;
             }
         }
@@ -20504,6 +20551,12 @@
     function isSingleRecordRequest(urlParams) {
         return hasOwnProperty$1.call(urlParams, 'recordId');
     }
+    function isRestrictedPathCondition(existingPath, path) {
+        // should not dedupe getRecordUi and getRecord as both of their representation is different
+        // records call cannot digest response of getRecordUi
+        return ((existingPath.includes('/record-ui') && path.includes('/records')) ||
+            (existingPath.includes('/records') && path.includes('/record-ui')));
+    }
 
     const createResourceRequest$12 = function getUiApiRecordsByRecordIdCreateResourceRequest(config) {
         return {
@@ -24860,7 +24913,7 @@
         // Temp fix until we can mimic the server behavior for non-layoutable entities.
         let layoutMap = {};
         if (hasOwnProperty$1.call(layouts, apiName)) {
-            layoutMap = layouts[apiName][recordTypeId];
+            layoutMap = layouts[apiName][recordTypeId] || {};
         }
         return {
             layoutMap,
@@ -25038,18 +25091,28 @@
      * These are intermediate lookups to check if the record is in the L2 cache
      * @param  {Luvio} luvio
      * @param  {GetRecordLayoutTypeConfig} config
-     * @param  {BuildCachedSnapshot<BuildSnapshotContext} cachedSnapshot
+     * @param  {BuildCachedSnapshot<BuildSnapshotContext>} 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, adapterContext }, cachedSnapshot, 
-        // this won't be invoked since we're requesting only-if-cached
+        return luvio.applyCachePolicy(
+        // Pass empty context so environment will use its default cache-policy
+        {}, { config, luvio, adapterContext }, cachedSnapshot, 
+        // disallow hitting the network by returning a gateway timeout
         () => {
-            throw Error('buildNetworkSnapshot should not be called for only-if-cached policy');
+            return new Promise((resolve) => {
+                resolve({
+                    state: 'Error',
+                    data: undefined,
+                    error: {
+                        body: undefined,
+                        headers: {},
+                        ok: false,
+                        status: 504,
+                        statusText: 'Gateway Timeout',
+                        errorType: 'fetchResponse',
+                    },
+                });
+            });
         });
     }
     /**
@@ -25260,7 +25323,7 @@
                 const responsePromises = [];
                 for (let i = 0, len = entries.length; i < len; i++) {
                     const { key, record } = entries[i];
-                    const node = luvio.wrapNormalizedGraphNode(record);
+                    const node = luvio.wrapNormalizedGraphNode(record, key);
                     const optionalFields = getTrackedFields(key, node, {
                         maxDepth: configurationForRestAdapters$1.getTrackedFieldDepthOnNotifyChange(),
                         onlyFetchLeafNodeIdAndName: configurationForRestAdapters$1.getTrackedFieldLeafNodeIdAndNameOnly(),
@@ -41158,7 +41221,16 @@
         throttle(60, 60000, createLDSAdapter(luvio, 'notifyListInfoUpdateAvailable', notifyUpdateAvailableFactory$1));
         throttle(60, 60000, createLDSAdapter(luvio, 'notifyQuickActionDefaultsUpdateAvailable', notifyUpdateAvailableFactory));
     });
-    // version: 1.228.1-0cb6f94f1
+    // version: 1.229.0-dev10-abb060196
+
+    var ldsIdempotencyWriteDisabled = {
+        isOpen: function (e) {
+            return e.fallback;
+        },
+        hasError: function () {
+            return !0;
+        },
+    };
 
     var caseSensitiveUserId = '005B0000000GR4OIAW';
 
@@ -41789,6 +41861,9 @@
     }
 
     function isStoreEntryError(storeRecord) {
+        if (!storeRecord || typeof storeRecord !== 'object') {
+            return false;
+        }
         return storeRecord.__type === 'error';
     }
 
@@ -42373,12 +42448,12 @@
             }
             return environment.getNode(key, ingestStagingStore);
         };
-        const wrapNormalizedGraphNode = function (normalized) {
+        const wrapNormalizedGraphNode = function (normalized, key) {
             validateNotDisposed();
             if (ingestStagingStore === null) {
                 ingestStagingStore = buildIngestStagingStore(environment);
             }
-            return environment.wrapNormalizedGraphNode(normalized, ingestStagingStore);
+            return environment.wrapNormalizedGraphNode(normalized, key, ingestStagingStore);
         };
         const rebuildSnapshot = function (snapshot, onRebuild) {
             validateNotDisposed();
@@ -42692,6 +42767,72 @@
         });
     }
 
+    /**
+     * Copyright (c) 2022, Salesforce, Inc.,
+     * All rights reserved.
+     * For full license text, see the LICENSE.txt file
+     */
+
+    const API_NAMESPACE$1 = 'UiApi';
+    const RECORD_REPRESENTATION_NAME$2 = 'RecordRepresentation';
+    const RECORD_VIEW_ENTITY_REPRESENTATION_NAME$1 = 'RecordViewEntityRepresentation';
+    const RECORD_ID_PREFIX$1 = `${API_NAMESPACE$1}::${RECORD_REPRESENTATION_NAME$2}:`;
+    const RECORD_VIEW_ENTITY_ID_PREFIX$1 = `${API_NAMESPACE$1}::${RECORD_VIEW_ENTITY_REPRESENTATION_NAME$1}:Name:`;
+    const RECORD_FIELDS_KEY_JUNCTION$1 = '__fields__';
+    function isStoreKeyRecordId(key) {
+        return key.indexOf(RECORD_ID_PREFIX$1) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION$1) === -1;
+    }
+    function isStoreKeyRecordViewEntity$1(key) {
+        return (key.indexOf(RECORD_VIEW_ENTITY_ID_PREFIX$1) > -1 &&
+            key.indexOf(RECORD_FIELDS_KEY_JUNCTION$1) === -1);
+    }
+    function isStoreKeyRecordField(key) {
+        return key.indexOf(RECORD_ID_PREFIX$1) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION$1) > -1;
+    }
+    function extractRecordIdFromStoreKey$1(key) {
+        if (key === undefined ||
+            (key.indexOf(RECORD_ID_PREFIX$1) === -1 && key.indexOf(RECORD_VIEW_ENTITY_ID_PREFIX$1) === -1)) {
+            return undefined;
+        }
+        const parts = key.split(':');
+        return parts[parts.length - 1].split('_')[0];
+    }
+    function buildRecordFieldStoreKey(recordKey, fieldName) {
+        return `${recordKey}${RECORD_FIELDS_KEY_JUNCTION$1}${fieldName}`;
+    }
+    function objectsDeepEqual(lhs, rhs) {
+        if (lhs === rhs)
+            return true;
+        if (typeof lhs !== 'object' || typeof rhs !== 'object' || lhs === null || rhs === null)
+            return false;
+        const lhsKeys = Object.keys(lhs);
+        const rhsKeys = Object.keys(rhs);
+        if (lhsKeys.length !== rhsKeys.length)
+            return false;
+        for (let key of lhsKeys) {
+            if (!rhsKeys.includes(key))
+                return false;
+            if (typeof lhs[key] === 'function' || typeof rhs[key] === 'function') {
+                if (lhs[key].toString() !== rhs[key].toString())
+                    return false;
+            }
+            else {
+                if (!objectsDeepEqual(lhs[key], rhs[key]))
+                    return false;
+            }
+        }
+        return true;
+    }
+
+    function isStoreRecordError(storeRecord) {
+        return storeRecord.__type === 'error';
+    }
+    function isEntryDurableRecordRepresentation(entry, key) {
+        // Either a DurableRecordRepresentation or StoreRecordError can live at a record key
+        return ((isStoreKeyRecordId(key) || isStoreKeyRecordViewEntity$1(key)) &&
+            entry.data.__type === undefined);
+    }
+
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
      * All rights reserved.
@@ -43951,6 +44092,7 @@
             'Email',
             'TextArea',
             'Percent',
+            'EncryptedString',
         ].includes(type);
     }
 
@@ -45431,8 +45573,12 @@
             // If there is no metadata for this query or it somehow lacks a timestamp
             // skip setting the root timestamp
             if (queryMetadata !== undefined && queryMetadata.ingestionTimestamp !== undefined) {
-                // subtract 10ms from timestamp to account for ingestion processing time
-                input.rootTimestamp = queryMetadata.ingestionTimestamp - 10;
+                const timestamp = Number(queryMetadata.ingestionTimestamp);
+                if (!isNaN(timestamp)) {
+                    // adjust the timestamp to account for ingestion processing time
+                    // 30s is used because this is the default record TTL
+                    input.rootTimestamp = timestamp - 30000;
+                }
             }
         }
         return recordQuery(selection, alias, apiName, [], input);
@@ -45890,7 +46036,11 @@
             try {
                 const { data, seenRecords } = await queryEvaluator(rootQuery, context, eventEmitter);
                 const rebuildWithStoreEval = ((originalSnapshot) => {
-                    return storeEval(config, originalSnapshot, observers, connectionKeyBuilder);
+                    return storeEval(config, originalSnapshot, observers, connectionKeyBuilder).then((rebuiltSnapshot) => {
+                        return objectsDeepEqual(originalSnapshot.data, rebuiltSnapshot.data)
+                            ? originalSnapshot
+                            : rebuiltSnapshot;
+                    });
                 });
                 const recordId = generateUniqueRecordId$1();
                 // if the non-eval'ed snapshot was an error then we return a synthetic
@@ -46241,8 +46391,12 @@
 
     const HTTP_HEADER_RETRY_AFTER = 'Retry-After';
     const HTTP_HEADER_IDEMPOTENCY_KEY = 'Idempotency-Key';
+    const ERROR_CODE_IDEMPOTENCY_FEATURE_NOT_ENABLED = 'IDEMPOTENCY_FEATURE_NOT_ENABLED';
+    const ERROR_CODE_IDEMPOTENCY_NOT_SUPPORTED = 'IDEMPOTENCY_NOT_SUPPORTED';
     const ERROR_CODE_IDEMPOTENCY_KEY_USED_DIFFERENT_USER = 'IDEMPOTENCY_KEY_USED_DIFFERENT_USER';
     const ERROR_CODE_IDEMPOTENCY_CONCURRENT_REQUEST = 'IDEMPOTENCY_CONCURRENT_REQUEST';
+    const ERROR_CODE_IDEMPOTENCY_KEY_ALREADY_USED = 'IDEMPOTENCY_KEY_ALREADY_USED';
+    const ERROR_CODE_IDEMPOTENCY_BACKEND_OPERATION_ERROR = 'IDEMPOTENCY_BACKEND_OPERATION_ERROR';
     /**
      * Get the retry after in milliseconds from the response headers, undefined if not specified.
      * The header could have two different format.
@@ -46272,7 +46426,9 @@
         const dispatchResourceRequest = async function (resourceRequest, _context) {
             const resourceRequestCopy = clone$1(resourceRequest);
             resourceRequestCopy.headers = resourceRequestCopy.headers || {};
-            resourceRequestCopy.headers[HTTP_HEADER_IDEMPOTENCY_KEY] = uuidv4();
+            if (handler.hasIdempotencySupport()) {
+                resourceRequestCopy.headers[HTTP_HEADER_IDEMPOTENCY_KEY] = uuidv4();
+            }
             // enable return extra fields for record creation and record update http call
             if (resourceRequest.basePath === '/ui-api/records' &&
                 (resourceRequest.method === 'post' || resourceRequest.method === 'patch')) {
@@ -47094,6 +47250,12 @@
             // the luvio store redirect table, during which a new draft might be enqueued
             // which would not see a necessary mapping.
             this.ephemeralRedirects = {};
+            // determined by Server setup.
+            this.isIdempotencySupported = true;
+            // idempotency write flag set by lds
+            this.isLdsIdempotencyWriteDisabled = ldsIdempotencyWriteDisabled.isOpen({
+                fallback: false,
+            });
         }
         enqueue(data) {
             return this.draftQueue.enqueue(this.handlerId, data);
@@ -47123,21 +47285,43 @@
                             retryDelayInMs = getRetryAfterInMs(response.headers);
                             shouldRetry = true;
                             break;
-                        case HttpStatusCode$1.ServerError:
+                        case HttpStatusCode$1.ServerError: {
                             shouldRetry = true;
+                            if (this.handleIdempotencyServerError(response.body, updatedAction, false, ERROR_CODE_IDEMPOTENCY_BACKEND_OPERATION_ERROR)) {
+                                this.isIdempotencySupported = false;
+                                retryDelayInMs = 0;
+                                actionDataChanged = true;
+                            }
                             break;
+                        }
                         case 409 /* IdempotentWriteSpecificHttpStatusCode.Conflict */: {
-                            const errorCode = response.body[0].errorCode;
-                            if (errorCode === ERROR_CODE_IDEMPOTENCY_KEY_USED_DIFFERENT_USER) {
-                                updatedAction.data.headers = updatedAction.data.headers || {};
-                                updatedAction.data.headers[HTTP_HEADER_IDEMPOTENCY_KEY] = uuidv4();
+                            if (this.isUiApiErrors(response.body)) {
+                                const errorCode = response.body[0].errorCode;
+                                if (this.handleIdempotencyServerError(response.body, updatedAction, true, ERROR_CODE_IDEMPOTENCY_KEY_USED_DIFFERENT_USER)) {
+                                    retryDelayInMs = 0;
+                                    actionDataChanged = true;
+                                }
+                                else if (errorCode === ERROR_CODE_IDEMPOTENCY_CONCURRENT_REQUEST) {
+                                    retryDelayInMs = getRetryAfterInMs(response.headers);
+                                }
+                                shouldRetry = true;
+                            }
+                            break;
+                        }
+                        case HttpStatusCode$1.BadRequest: {
+                            if (this.handleIdempotencyServerError(response.body, updatedAction, false, ERROR_CODE_IDEMPOTENCY_FEATURE_NOT_ENABLED, ERROR_CODE_IDEMPOTENCY_NOT_SUPPORTED)) {
                                 retryDelayInMs = 0;
                                 actionDataChanged = true;
+                                shouldRetry = true;
                             }
-                            else if (errorCode === ERROR_CODE_IDEMPOTENCY_CONCURRENT_REQUEST) {
-                                retryDelayInMs = getRetryAfterInMs(response.headers);
+                            break;
+                        }
+                        case 422 /* IdempotentWriteSpecificHttpStatusCode.UnProcessableEntity */: {
+                            if (this.handleIdempotencyServerError(response.body, updatedAction, true, ERROR_CODE_IDEMPOTENCY_KEY_ALREADY_USED)) {
+                                retryDelayInMs = 0;
+                                actionDataChanged = true;
+                                shouldRetry = true;
                             }
-                            shouldRetry = true;
                             break;
                         }
                     }
@@ -47156,6 +47340,27 @@
                 return ProcessActionResult.NETWORK_ERROR;
             }
         }
+        // true if response is an idempotency server error. updates or deletes idempotency key if the reponse is idempotency related error. Idempotency related error is in format of UiApiError array.
+        handleIdempotencyServerError(responseBody, action, updateIdempotencyKey, ...targetErrorCodes) {
+            if (this.isUiApiErrors(responseBody)) {
+                const errorCode = responseBody[0].errorCode;
+                if (targetErrorCodes.includes(errorCode)) {
+                    action.data.headers = action.data.headers || {};
+                    if (updateIdempotencyKey) {
+                        action.data.headers[HTTP_HEADER_IDEMPOTENCY_KEY] = uuidv4();
+                    }
+                    else {
+                        delete action.data.headers[HTTP_HEADER_IDEMPOTENCY_KEY];
+                    }
+                    return true;
+                }
+            }
+            return false;
+        }
+        // checks if the body is an array of UiApiError. Sometimes the body has `enhancedErrorType` field as an error indicator(one example is the field validation failure). In such case Action being processed updates to an Error Action.
+        isUiApiErrors(body) {
+            return body !== undefined && Array.isArray(body) && body.length > 0 && body[0].errorCode;
+        }
         async buildPendingAction(request, queue) {
             const targetId = await this.getIdFromRequest(request);
             if (targetId === undefined) {
@@ -47369,6 +47574,10 @@
                 ...targetData,
                 body: this.mergeRequestBody(targetBody, sourceBody),
             };
+            // Updates Idempotency key if target has one
+            if (targetData.headers && targetData.headers[HTTP_HEADER_IDEMPOTENCY_KEY]) {
+                merged.data.headers[HTTP_HEADER_IDEMPOTENCY_KEY] = uuidv4();
+            }
             // overlay metadata
             merged.metadata = { ...targetMetadata, ...sourceMetadata };
             // put status back to pending to auto upload if queue is active and targed is at the head.
@@ -47405,6 +47614,9 @@
         getDraftIdsFromAction(action) {
             return [action.targetId];
         }
+        hasIdempotencySupport() {
+            return this.isIdempotencySupported && !this.isLdsIdempotencyWriteDisabled;
+        }
         async ingestResponses(responses, action) {
             const luvio = this.getLuvio();
             await luvio.handleSuccessResponse(() => {
@@ -47836,49 +48048,6 @@
         });
     }
 
-    /**
-     * Copyright (c) 2022, Salesforce, Inc.,
-     * All rights reserved.
-     * For full license text, see the LICENSE.txt file
-     */
-
-    const API_NAMESPACE$1 = 'UiApi';
-    const RECORD_REPRESENTATION_NAME$2 = 'RecordRepresentation';
-    const RECORD_VIEW_ENTITY_REPRESENTATION_NAME$1 = 'RecordViewEntityRepresentation';
-    const RECORD_ID_PREFIX$1 = `${API_NAMESPACE$1}::${RECORD_REPRESENTATION_NAME$2}:`;
-    const RECORD_VIEW_ENTITY_ID_PREFIX$1 = `${API_NAMESPACE$1}::${RECORD_VIEW_ENTITY_REPRESENTATION_NAME$1}:Name:`;
-    const RECORD_FIELDS_KEY_JUNCTION$1 = '__fields__';
-    function isStoreKeyRecordId(key) {
-        return key.indexOf(RECORD_ID_PREFIX$1) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION$1) === -1;
-    }
-    function isStoreKeyRecordViewEntity$1(key) {
-        return (key.indexOf(RECORD_VIEW_ENTITY_ID_PREFIX$1) > -1 &&
-            key.indexOf(RECORD_FIELDS_KEY_JUNCTION$1) === -1);
-    }
-    function isStoreKeyRecordField(key) {
-        return key.indexOf(RECORD_ID_PREFIX$1) > -1 && key.indexOf(RECORD_FIELDS_KEY_JUNCTION$1) > -1;
-    }
-    function extractRecordIdFromStoreKey$1(key) {
-        if (key === undefined ||
-            (key.indexOf(RECORD_ID_PREFIX$1) === -1 && key.indexOf(RECORD_VIEW_ENTITY_ID_PREFIX$1) === -1)) {
-            return undefined;
-        }
-        const parts = key.split(':');
-        return parts[parts.length - 1].split('_')[0];
-    }
-    function buildRecordFieldStoreKey(recordKey, fieldName) {
-        return `${recordKey}${RECORD_FIELDS_KEY_JUNCTION$1}${fieldName}`;
-    }
-
-    function isStoreRecordError(storeRecord) {
-        return storeRecord.__type === 'error';
-    }
-    function isEntryDurableRecordRepresentation(entry, key) {
-        // Either a DurableRecordRepresentation or StoreRecordError can live at a record key
-        return ((isStoreKeyRecordId(key) || isStoreKeyRecordViewEntity$1(key)) &&
-            entry.data.__type === undefined);
-    }
-
     function serializeFieldArguments$1(argumentNodes, variables) {
         const mutableArgumentNodes = Object.assign([], argumentNodes);
         return `args__(${mutableArgumentNodes
@@ -49253,6 +49422,10 @@
         return node.kind === 'OperationDefinition';
     }
 
+    const POLYMORPHIC_PARENT_RELATIONSHIP = 'polymorphicParentRelationship';
+    const PARENT_RELATIONSHIP = 'parentRelationship';
+    const CHILD_RELATIONSHIP = 'childRelationship';
+    const RECORD_QUERY = 'recordQuery';
     function requestsDraftsField(recordFieldNode) {
         if (!recordFieldNode.selectionSet)
             return false;
@@ -49268,18 +49441,41 @@
                     directive.arguments
                         .map((argument) => argument.value)
                         .filter(isStringValueNode)
-                        .some((categoryName) => categoryName.value === 'recordQuery'));
+                        .some((categoryName) => categoryName.value === RECORD_QUERY));
             });
         }
         return false;
     }
-    // finds field with 'recordQuery' and 'childRelationship' directive
-    function findNearestRecordQuery(ancestors) {
-        const recordQueryAncester = findNearestAncesterPath(ancestors, true).node;
-        return recordQueryAncester === undefined ? undefined : recordQueryAncester;
+    // finds connection field with 'recordQuery' and 'childRelationship' directive.
+    function findNearestConnection(ancestors) {
+        const connectionAncestor = findNearestAncesterPath(ancestors, true).node;
+        return connectionAncestor === undefined ? undefined : connectionAncestor;
+    }
+    // convinient method to find nearest connection with its path
+    function findNearestConnectionWithPath(ancestors) {
+        const closestAncestorPath = findNearestAncesterPath(ancestors, true);
+        let connection = undefined;
+        let connectionPath = undefined;
+        if (closestAncestorPath.parentIndex > 0) {
+            const connectionAncestor = closestAncestorPath.node;
+            const connectionAncestors = ancestors.slice(0, closestAncestorPath.parentIndex);
+            connection =
+                connectionAncestor === undefined ? undefined : connectionAncestor;
+            if (connection !== undefined) {
+                const ancesterPath = findAncesterPath(connectionAncestors);
+                connectionPath =
+                    ancesterPath === ''
+                        ? connection.name.value
+                        : `${ancesterPath}#${connection.name.value}`;
+            }
+        }
+        return {
+            connection,
+            path: connectionPath,
+        };
     }
-    // finds cloeset ancester. If 'parentRelationship' is allowed, it could be 'InlineFragmentNode' since it inherits the 'parent' relationship. 'InlineFragmentNode' makes sure that only one 'apiName' returns when tree is traversed.
-    function findNearestAncesterPath(ancestors, recordQueryOnly) {
+    // finds closest ancestor. If node with 'parentRelationship' is the ancester, the end result could be 'InlineFragmentNode' since it inherits the 'parent' relationship. 'InlineFragmentNode' makes sure that only one 'apiName' returns when tree is traversed.
+    function findNearestAncesterPath(ancestors, connectionOnly) {
         let recordQueryPath = { node: undefined, parentIndex: -1 };
         let relationship = '';
         for (let i = ancestors.length - 1; i >= 0; i--) {
@@ -49293,9 +49489,11 @@
                     continue;
                 for (let arg of directive.arguments) {
                     if (arg.value &&
-                        (arg.value.value === 'recordQuery' ||
-                            arg.value.value === 'childRelationship' ||
-                            (!recordQueryOnly && arg.value.value === 'parentRelationship'))) {
+                        (arg.value.value === RECORD_QUERY ||
+                            arg.value.value === CHILD_RELATIONSHIP ||
+                            (!connectionOnly &&
+                                (arg.value.value === PARENT_RELATIONSHIP ||
+                                    arg.value.value === POLYMORPHIC_PARENT_RELATIONSHIP)))) {
                         recordQueryPath = { node: node, parentIndex: i };
                         relationship = arg.value.value;
                         break;
@@ -49310,17 +49508,19 @@
         //checks if nearest ancester could be an inline fragment
         if (recordQueryPath.node !== undefined &&
             recordQueryPath.node.selectionSet &&
-            relationship === 'parentRelationship') {
-            //
-            if (recordQueryPath.node.selectionSet.selections.every(isInlineFragmentNode)) {
-                //
-                const inlineFragmentLoc = recordQueryPath.parentIndex + 2;
-                if (inlineFragmentLoc < ancestors.length && ancestors[inlineFragmentLoc]) {
+            (relationship === PARENT_RELATIONSHIP || relationship === POLYMORPHIC_PARENT_RELATIONSHIP)) {
+            // InlineFragment is usually 3 steps aways from its FieldNode parent within ancester hierarchy if it exists. The below search
+            // is applied to adapt to future AST structure change
+            let parentIndex = recordQueryPath.parentIndex + 1;
+            while (parentIndex < ancestors.length) {
+                if (isInlineFragmentNode(ancestors[parentIndex])) {
                     recordQueryPath = {
-                        node: ancestors[inlineFragmentLoc],
-                        parentIndex: inlineFragmentLoc,
+                        node: ancestors[parentIndex],
+                        parentIndex,
                     };
+                    break;
                 }
+                parentIndex++;
             }
         }
         return recordQueryPath;
@@ -49344,7 +49544,7 @@
                             ? sectionPath
                             : sectionPath === ''
                                 ? path
-                                : `${sectionPath}_${path}`;
+                                : `${sectionPath}#${path}`;
                 }
             }
             boundaryIndex = parentIndex;
@@ -49402,9 +49602,9 @@
             const relationships = args
                 .map((arg) => arg.value)
                 .filter(isStringValueNode)
-                .filter((valueNode) => valueNode.value === 'childRelationship' ||
-                valueNode.value === 'parentRelationship' ||
-                valueNode.value === 'polymorphicParentRelationship')
+                .filter((valueNode) => valueNode.value === CHILD_RELATIONSHIP ||
+                valueNode.value === PARENT_RELATIONSHIP ||
+                valueNode.value === POLYMORPHIC_PARENT_RELATIONSHIP)
                 .map((relationshipNode) => relationshipNode.value);
             if (relationships.length > 0) {
                 return relationships[0];
@@ -49461,8 +49661,8 @@
      */
     function isParentRelationship(node) {
         return (node &&
-            (isRelationship(node, 'parentRelationship') ||
-                isRelationship(node, 'polymorphicParentRelationship')));
+            (isRelationship(node, PARENT_RELATIONSHIP) ||
+                isRelationship(node, POLYMORPHIC_PARENT_RELATIONSHIP)));
     }
     /*
     checks if the InlineFragment spans
@@ -49768,6 +49968,26 @@
         return values$1(objectInfo.fields).find((field) => field.apiName === fieldName ||
             (field.dataType === 'Reference' && field.relationshipName === fieldName));
     }
+    async function readIngestionTimestampForKey(key, query) {
+        let ingestionTimestamp = 0;
+        const sql = `
+                    SELECT json_extract(metadata, '${JSON_EXTRACT_PATH_INGESTION_TIMESTAMP}') 
+                    FROM lds_data 
+                    WHERE key IS ?
+                    `;
+        const results = await query(sql, [key]);
+        const [timestamp] = results.rows.map((row) => row[0]);
+        if (timestamp !== null) {
+            const numericalTimestamp = Number(timestamp);
+            if (isNaN(numericalTimestamp)) {
+                return ingestionTimestamp;
+            }
+            // adjust the timestamp to account for ingestion processing time
+            // 30s is used because this is the default record TTL
+            ingestionTimestamp = numericalTimestamp - 30000;
+        }
+        return ingestionTimestamp;
+    }
 
     function findSpanningField(name) {
         return (field) => {
@@ -50287,17 +50507,7 @@
             const key = buildKeyStringForRecordQuery(operation, 
             // join varables passed from query to the argument variables given from the AST
             { ...variableValues, ...args }, info.fieldNodes[0].arguments, apiName);
-            const sql = `
-                    SELECT json_extract(metadata, '${JSON_EXTRACT_PATH_INGESTION_TIMESTAMP}') 
-                    FROM lds_data 
-                    WHERE key IS ?
-                    `;
-            const results = await query(sql, [key]);
-            const [timestamp] = results.rows.map((row) => row[0]);
-            if (timestamp !== null && typeof timestamp === 'number') {
-                //go back 10 ms to adjust for margin of error when top level query is stored and when raml objects are stored
-                ingestionTimestamp = timestamp - 10;
-            }
+            return readIngestionTimestampForKey(key, query);
         }
         return ingestionTimestamp;
     }
@@ -50345,26 +50555,20 @@
         let recordConnections = ``;
         const polymorphicFieldTypeNames = new Set();
         let typedScalars = new Set();
+        let parentRelationshipFields = new Set();
         for (const objectInfo of values$1(objectInfos)) {
             const { apiName, childRelationships } = objectInfo;
             let fields = ``;
             typedScalars.add(`${apiName}_Filter`);
             typedScalars.add(`${apiName}_OrderBy`);
-            for (const childRelationship of childRelationships) {
-                const { childObjectApiName } = childRelationship;
-                // Only add the relationship if there is relevant objectinfos for it,
-                // otherwise we'd be defining types we cannot satisfy and aren't referenced in
-                // the query.
-                if (objectInfos[childObjectApiName] !== undefined) {
-                    fields += `${childRelationship.relationshipName}(first: Int, where: ${childObjectApiName}_Filter, orderBy: ${childObjectApiName}_OrderBy, scope: SupportedScopes): ${childObjectApiName}Connection \n`;
-                    typedScalars.add(`${childObjectApiName}_Filter`);
-                    typedScalars.add(`${childObjectApiName}_OrderBy`);
-                }
-            }
             for (const field of values$1(objectInfo.fields)) {
                 if (!fieldsStaticallyAdded.includes(field.apiName)) {
                     fields += `${field.apiName}: ${dataTypeToType(field.dataType, field.apiName)}\n`;
                 }
+                //handles parent relationship
+                if (field.relationshipName === null) {
+                    continue;
+                }
                 // For spanning parent relationships with no union types
                 if (field.referenceToInfos.length === 1) {
                     const [relation] = field.referenceToInfos;
@@ -50372,11 +50576,13 @@
                     // otherwise we'd be defining types we cannot satisfy and aren't referenced in
                     // the query.
                     if (objectInfos[relation.apiName] !== undefined) {
+                        parentRelationshipFields.add(field.relationshipName);
                         fields += `${field.relationshipName}: ${relation.apiName}\n`;
                     }
                     // For polymorphic field, its type is 'Record' inteface. The concrete entity type name is saved for field resolving of next phase
                 }
                 else if (field.referenceToInfos.length > 1) {
+                    parentRelationshipFields.add(field.relationshipName);
                     fields += `${field.relationshipName}: Record\n`;
                     for (const relation of field.referenceToInfos) {
                         if (objectInfos[relation.apiName] !== undefined) {
@@ -50385,6 +50591,20 @@
                     }
                 }
             }
+            // handles child relationship
+            for (const childRelationship of childRelationships) {
+                const { childObjectApiName } = childRelationship;
+                // Only add the relationship if there is relevant objectinfos for it,
+                // otherwise we'd be defining types we cannot satisfy and aren't referenced in
+                // the query.
+                // If one field has both parent relationship and child relationship with the same name, the child relationship is ignored. This is how the server GQL has implemented as date of 08/07/2023
+                if (objectInfos[childObjectApiName] !== undefined &&
+                    !parentRelationshipFields.has(childRelationship.relationshipName)) {
+                    fields += `${childRelationship.relationshipName}(first: Int, where: ${childObjectApiName}_Filter, orderBy: ${childObjectApiName}_OrderBy, scope: SupportedScopes): ${childObjectApiName}Connection \n`;
+                    typedScalars.add(`${childObjectApiName}_Filter`);
+                    typedScalars.add(`${childObjectApiName}_OrderBy`);
+                }
+            }
             recordQueries += `${apiName}(first: Int, where: ${apiName}_Filter, orderBy: ${apiName}_OrderBy, scope: SupportedScopes): ${apiName}Connection\n`;
             const isServiceAppointment = apiName === 'ServiceAppointment';
             recordConnections += /* GraphQL */ `
@@ -50459,6 +50679,8 @@
                 return 'PercentValue';
             case 'Int':
                 return 'IntValue';
+            case 'EncryptedString':
+                return 'EncryptedStringValue';
             // ! do the rest of the custom types
             default:
                 return 'String';
@@ -50544,7 +50766,7 @@
                 },
                 value: {
                     kind: Kind.STRING,
-                    value: 'parentRelationship',
+                    value: PARENT_RELATIONSHIP,
                     block: false,
                 },
             },
@@ -50558,8 +50780,8 @@
         // example 2 'ServiceAppointment' -> ['Owner']; 'Owner' -> ['User', 'Group']
         const objectNodeInfoTree = {};
         // save the field path to apiName map
-        // example 1: 'ServiceAppointment' -> ['ServiceAppointment']; 'ServiceAppointment_Account' -> ['Account']; 'ServiceAppointment_Account_Owner' -> ['User']
-        const objectInfoApiMap = {};
+        // example 1: 'ServiceAppointment' -> ['ServiceAppointment']; 'ServiceAppointment#ccount' -> ['Account']; 'ServiceAppointment#Account#Owner' -> ['User']
+        const pathToObjectApiNamesMap = {};
         let startNodes = new Set();
         let totalNodes = new Set();
         let objectInfos = {};
@@ -50573,11 +50795,11 @@
         visit(originalAST, {
             Argument: {
                 enter(node, key, parent, path, ancestors) {
-                    const recordQueryNode = findNearestRecordQuery(ancestors);
-                    if (!recordQueryNode)
+                    const { connection: recordConnectionNode, path: ancesterPath } = findNearestConnectionWithPath(ancestors);
+                    if (!recordConnectionNode || !ancesterPath)
                         return;
-                    if (!objectNodeInfoTree[recordQueryNode.name.value]) {
-                        objectNodeInfoTree[recordQueryNode.name.value] = [];
+                    if (!objectNodeInfoTree[ancesterPath]) {
+                        objectNodeInfoTree[ancesterPath] = [];
                     }
                     switch (node.name.value) {
                         case 'orderBy':
@@ -50585,12 +50807,12 @@
                             if (node.value.kind !== 'ObjectValue') {
                                 return;
                             }
-                            totalNodes.add(recordQueryNode.name.value);
+                            totalNodes.add(ancesterPath);
                             // 'childRelationship' node is not taken as the startNode of the 'NodeInfoTree' graph. The field scanning will construct the graph which lead here.
-                            if (isRecordQuery(recordQueryNode)) {
-                                startNodes.add(recordQueryNode.name.value);
+                            if (isRecordQuery(recordConnectionNode)) {
+                                startNodes.add(recordConnectionNode.name.value);
                             }
-                            growObjectFieldTree(objectNodeInfoTree, recordQueryNode.name.value, node.value, totalNodes, startNodes);
+                            growObjectFieldTree(objectNodeInfoTree, ancesterPath, node.value, totalNodes, startNodes);
                             break;
                         case 'scope':
                             if (!isScopeArgumentNodeWithType(node, 'ASSIGNEDTOME', variables)) {
@@ -50605,17 +50827,16 @@
                                     name: 'ServiceResources',
                                 });
                             }
-                            if (objectNodeInfoTree['ServiceResources'] === undefined) {
-                                objectNodeInfoTree['ServiceResources'] = [];
-                            }
-                            if (!objectNodeInfoTree['ServiceResources'].some((child) => child.name === 'ServiceResource')) {
-                                objectNodeInfoTree['ServiceResources'].push({
-                                    relation: 'parent',
-                                    name: 'ServiceResource',
-                                });
+                            if (objectNodeInfoTree['ServiceAppointment#ServiceResources'] === undefined) {
+                                objectNodeInfoTree['ServiceAppointment#ServiceResources'] = [
+                                    {
+                                        relation: 'parent',
+                                        name: 'ServiceResource',
+                                    },
+                                ];
                             }
-                            if (objectNodeInfoTree['ServiceResource'] === undefined) {
-                                objectNodeInfoTree['ServiceResource'] = [];
+                            if (objectNodeInfoTree['ServiceAppointment#ServiceResources#ServiceResource'] === undefined) {
+                                objectNodeInfoTree['ServiceAppointment#ServiceResources#ServiceResource'] = [];
                             }
                             break;
                         default:
@@ -50629,7 +50850,7 @@
                         return;
                     if (!node.selectionSet)
                         return;
-                    const recordQueryField = findNearestRecordQuery(ancestors);
+                    const recordQueryField = findNearestConnection(ancestors);
                     //only injects fields for 'recordQuery' field. ignores the 'childRelationship' field since it will be traversed as the child of the 'recordQuery'
                     if (isRecordQuery(recordQueryField) && recordQueryField) {
                         totalNodes.add(recordQueryField.name.value);
@@ -50640,21 +50861,21 @@
             },
         });
         if (objectInfoService && startNodes.size > 0) {
-            objectInfos = await resolveObjectInfos(objectNodeInfoTree, objectInfoApiMap, startNodes, objectInfoService);
+            objectInfos = await resolveObjectInfos(objectNodeInfoTree, pathToObjectApiNamesMap, startNodes, objectInfoService);
         }
         // read pass; gather whats needed
         visit(originalAST, {
             Argument: {
                 leave(node, key, parent, path, ancestors) {
-                    const recordQueryField = findNearestRecordQuery(ancestors);
+                    const recordQueryField = findNearestConnection(ancestors);
                     if (!recordQueryField)
                         return;
                     const ancestorPath = findAncesterPath(ancestors);
                     if (!inlineFragmentSelections[ancestorPath]) {
                         inlineFragmentSelections[ancestorPath] = [];
                     }
-                    const recordQueryApiName = objectInfoApiMap[ancestorPath]
-                        ? objectInfoApiMap[ancestorPath][0]
+                    const recordQueryApiName = pathToObjectApiNamesMap[ancestorPath]
+                        ? pathToObjectApiNamesMap[ancestorPath][0]
                         : recordQueryField.name.value;
                     // The record node acts as the reference. The duplicated field in the record node is not injected
                     const recordReferenceNode = [recordQueryField]
@@ -50668,7 +50889,7 @@
                         case 'scope':
                             // Hanle 'MINE' field
                             if (isScopeArgumentNodeWithType(node, 'MINE', variables)) {
-                                if (isMineScopeAvailable(ancestorPath, objectInfoApiMap, objectInfos)) {
+                                if (isMineScopeAvailable(ancestorPath, pathToObjectApiNamesMap, objectInfos)) {
                                     // 'typeConditon' is added when the 'InlineFragmentNode' is appended at the write pass
                                     inlineFragmentSelections[ancestorPath].push(...mineFragmentSelections);
                                 }
@@ -50694,7 +50915,7 @@
                         case 'where': {
                             inlineFragmentSelections[ancestorPath] = [
                                 ...inlineFragmentSelections[ancestorPath],
-                                ...injectFilter(node, idState, ancestorPath, objectInfos, objectInfoApiMap, draftFunctions, recordReferenceNode),
+                                ...injectFilter(node, idState, ancestorPath, false, objectInfos, pathToObjectApiNamesMap, draftFunctions, recordReferenceNode),
                             ];
                             break;
                         }
@@ -50710,7 +50931,7 @@
                     if (!node.selectionSet)
                         return;
                     // it could be 'recordQuery' or 'childRelationship'
-                    const recordQueryField = findNearestRecordQuery(ancestors);
+                    const recordQueryField = findNearestConnection(ancestors);
                     if (!recordQueryField)
                         return;
                     const ancestorPath = findAncesterPath(ancestors);
@@ -50722,7 +50943,7 @@
                             spanningSelections.push(selection);
                         }
                     }
-                    const injectedFields = injectFields(spanningSelections, node, ancestors, objectInfos, objectInfoApiMap);
+                    const injectedFields = injectFields(spanningSelections, node, ancestorPath, ancestors, objectInfos, pathToObjectApiNamesMap);
                     const mergedInjectedFields = mergeSelectionNodes$1(inlineFragmentSelections[ancestorPath], injectedFields);
                     inlineFragmentSelections[ancestorPath] = mergedInjectedFields;
                 },
@@ -50735,7 +50956,7 @@
                     // removes 'ServicesResources' query field node if 'assignedtome' scope shows up
                     if (assignedtomeQueryFieldNode !== undefined &&
                         node.name.value === 'ServiceResources') {
-                        const serviceResourcesAncestor = findNearestRecordQuery(ancestors);
+                        const serviceResourcesAncestor = findNearestConnection(ancestors);
                         if (serviceResourcesAncestor === assignedtomeQueryFieldNode) {
                             return null;
                         }
@@ -50744,7 +50965,7 @@
                         return;
                     if (!node.selectionSet)
                         return;
-                    const recordQueryField = findNearestRecordQuery(ancestors);
+                    const recordQueryField = findNearestConnection(ancestors);
                     if (!recordQueryField)
                         return;
                     const ancestorPath = findAncesterPath(ancestors);
@@ -50753,8 +50974,8 @@
                         return;
                     //const recordQueryPath = findAncesterPath(ancestors);
                     // 'apiName' has to be at index 0 since 'node' record type could only be of 'recordQuery' or 'childRelationship'. They can not have the 'InlineFragmentNode' as its children.
-                    const recordQueryApiName = objectInfoApiMap[ancestorPath]
-                        ? objectInfoApiMap[ancestorPath][0]
+                    const recordQueryApiName = pathToObjectApiNamesMap[ancestorPath]
+                        ? pathToObjectApiNamesMap[ancestorPath][0]
                         : recordQueryField.name.value;
                     const nodeWithFragments = {
                         ...node,
@@ -50791,7 +51012,7 @@
                     if (node.name.value === 'where') {
                         const ancestorPath = findAncesterPath(ancestors);
                         if (idState.paths.includes(ancestorPath)) {
-                            const apiName = objectInfoApiMap[ancestorPath][0];
+                            const apiName = pathToObjectApiNamesMap[ancestorPath][0];
                             const objectInfo = objectInfos[apiName];
                             const swappedIdFilter = swapIdField(node.value, objectInfo, false, idState, draftFunctions);
                             return {
@@ -50857,8 +51078,8 @@
                 };
         }
     }
-    function isMineScopeAvailable(apiNamePath, objectInfoApiMap, objectInfos) {
-        const apiName = objectInfoApiMap[apiNamePath];
+    function isMineScopeAvailable(apiNamePath, pathToObjectApiNamesMap, objectInfos) {
+        const apiName = pathToObjectApiNamesMap[apiNamePath];
         if (!apiName)
             return false;
         const objectInfo = objectInfos[apiName[0]];
@@ -50947,15 +51168,16 @@
                         }
                         // example: 'Account'
                         const childNode = objectFieldNode.name.value;
+                        const childNodepath = `${parentNode}#${childNode}`;
                         if (!tree[parentNode].some((child) => child.name === childNode)) {
                             tree[parentNode].push({
                                 relation: 'parent',
                                 name: childNode,
                             });
-                            totalNodes.add(childNode);
+                            totalNodes.add(childNodepath);
                         }
                         // recursively go to deeper level of filter.
-                        growObjectFieldTree(tree, childNode, objectFieldNode.value, totalNodes, startNodes);
+                        growObjectFieldTree(tree, childNodepath, objectFieldNode.value, totalNodes, startNodes);
                     }
                 }
             }
@@ -50990,19 +51212,20 @@
                     }
                     if (!tree[parentSectionPath].some((field) => field.name === fieldName)) {
                         tree[parentSectionPath].push({
-                            relation: relationType === 'parentRelationship' ||
-                                relationType === 'polymorphicParentRelationship'
+                            relation: relationType === PARENT_RELATIONSHIP ||
+                                relationType === POLYMORPHIC_PARENT_RELATIONSHIP
                                 ? 'parent'
                                 : 'child',
                             name: fieldName,
                         });
-                        totalNodes.add(fieldName);
+                        totalNodes.add(`${parentSectionPath}#${fieldName}`);
                     }
                     if (entryNode.selectionSet && entryNode.selectionSet.selections) {
                         const childNodes = entryNode.selectionSet.selections.filter(isFieldOrInlineFragmentNode);
                         // recursively build the traversal tree
                         for (const child of childNodes) {
-                            growFieldTree(tree, fieldName, child, entryNode, totalNodes, startNodes);
+                            const path = `${parentSectionPath}#${fieldName}`;
+                            growFieldTree(tree, path, child, entryNode, totalNodes, startNodes);
                         }
                     }
                 }
@@ -51032,23 +51255,23 @@
                         }
                         if (!tree[parentSectionPath].some((field) => field.name === conditionName)) {
                             tree[parentSectionPath].push({
-                                relation: relationType === 'parentRelationship' ||
-                                    relationType === 'polymorphicParentRelationship'
+                                relation: relationType === PARENT_RELATIONSHIP ||
+                                    relationType === POLYMORPHIC_PARENT_RELATIONSHIP
                                     ? 'parent'
                                     : 'child',
                                 name: conditionName,
                             });
-                            totalNodes.add(conditionName);
+                            const path = `${parentSectionPath}#${conditionName}`;
+                            totalNodes.add(path);
                         }
                     }
                 }
                 // dive deep immediately for 'InlineFragment'
                 const childNodes = entryNode.selectionSet.selections.filter(isFieldOrInlineFragmentNode);
+                const path = `${parentSectionPath}${entryNode.typeCondition ? '#' + entryNode.typeCondition.name.value : ''}`;
                 // Navigates into InLineFragment
                 for (const child of childNodes) {
-                    growFieldTree(tree, entryNode.typeCondition
-                        ? entryNode.typeCondition.name.value
-                        : parentSectionPath, child, entryNode, totalNodes, startNodes);
+                    growFieldTree(tree, path, child, entryNode, totalNodes, startNodes);
                 }
             }
         }
@@ -51060,7 +51283,7 @@
      * @param startNodes start nodes of the tree. It can be used to fetch ObjectInfo immediately
      * @param path
      */
-    async function resolveObjectInfos(objectInfotree, objectInfoApiMap, startNodes, objectInfoService) {
+    async function resolveObjectInfos(objectInfotree, pathToObjectApiNamesMap, startNodes, objectInfoService) {
         let objectInfos;
         try {
             objectInfos = await objectInfoService.getObjectInfos(Array.from(startNodes));
@@ -51074,9 +51297,9 @@
             throw new Error(`Unable to resolve ObjectInfo(s) for ${Array.from(startNodes)}`);
         }
         for (const startNode of startNodes) {
-            objectInfoApiMap[startNode] = [startNode];
+            pathToObjectApiNamesMap[startNode] = [startNode];
             const children = objectInfotree[startNode];
-            const subObjectInfoMap = await fetchObjectInfos(objectInfotree, objectInfoApiMap, objectInfos, children, startNode, objectInfoService);
+            const subObjectInfoMap = await fetchObjectInfos(objectInfotree, pathToObjectApiNamesMap, objectInfos, children, startNode, objectInfoService);
             objectInfos = { ...objectInfos, ...subObjectInfoMap };
         }
         return objectInfos;
@@ -51084,15 +51307,15 @@
     // example 1: 'parentPath': 'ServiceAppointment', 'nodesAtSameLevel': ['Account']
     // example 2: 'parentPath': 'ServiceAppointment', 'nodesAtSameLevel': ['Owner'], this example has 2 apiName for the node 'Owner'
     // example 3: 'parentPath': 'ServiceAppointment_Owner', 'nodesAtSameLevel': ['User', 'Group']
-    async function fetchObjectInfos(objectInfotree, objectInfoApiMap, objectInfoMap, nodesAtSameLevel, parentPath, objectInfoService) {
-        const objectInfoApiNames = objectInfoApiMap[parentPath];
+    async function fetchObjectInfos(objectInfotree, pathToObjectApiNamesMap, objectInfoMap, nodesAtSameLevel, parentPath, objectInfoService) {
+        const objectInfoApiNames = pathToObjectApiNamesMap[parentPath];
         if (!objectInfoApiNames) {
             // eslint-disable-next-line
             throw new Error(`Object Info does not exist for ${parentPath}`);
         }
         const validObjectInfoNodes = [];
         let updatedObjectInfoMap = {};
-        // InlineFragment and polymorphic field support fits into this scenario  ObjectInfoApiMap Entry:  'ServiceAppointment_Owner' -> ['User', 'Group']; ServiceAppointment_Owner_User' -> ['User']
+        // InlineFragment and polymorphic field support fits into this scenario  pathToObjectApiNamesMap Entry:  'ServiceAppointment#Owner' -> ['User', 'Group']; ServiceAppointment#Owner#User' -> ['User']
         if (objectInfoApiNames.length > 0 &&
             nodesAtSameLevel.length > 0 &&
             objectInfoApiNames.includes(nodesAtSameLevel[0].name)) {
@@ -51104,8 +51327,8 @@
                     // eslint-disable-next-line
                     throw new Error(`Condition ${field.name} does not exists for ${parentPath}`);
                 }
-                const path = `${parentPath}_${field.name}`;
-                objectInfoApiMap[path] = [field.name];
+                const path = `${parentPath}#${field.name}`;
+                pathToObjectApiNamesMap[path] = [field.name];
             }
             validObjectInfoNodes.push(...nodesAtSameLevel);
             updatedObjectInfoMap = { ...objectInfoMap };
@@ -51120,7 +51343,7 @@
             let apiNames = [];
             for (const nodeInfo of nodesAtSameLevel) {
                 const field = nodeInfo.name;
-                const path = `${parentPath}_${field}`;
+                const path = `${parentPath}#${field}`;
                 // Handle 'parentRelationship'
                 if (nodeInfo.relation === 'parent') {
                     const relationshipId = referenceIdFieldForRelationship(field);
@@ -51138,21 +51361,21 @@
                         }
                     }
                     // This is a polymorphic field
-                    if (fieldDefinition.referenceToInfos.length > 1 && objectInfotree[field]) {
+                    if (fieldDefinition.referenceToInfos.length > 1 && objectInfotree[path]) {
                         // Fields needs to expand and heterogenous entity ObjectInfo needs to be fetched
-                        const referencedNodeInfos = objectInfotree[field];
+                        const referencedNodeInfos = objectInfotree[path];
                         const requestedApiNames = referencedNodeInfos.map((referenceNodeInfo) => referenceNodeInfo.name);
                         // Fetches requested ObjectInfo only. Some entity's relation field could define more than 6 references. Only references show up in query need to be handled.
-                        if (requestedApiNames.length > 0 && objectInfotree[field]) {
+                        if (requestedApiNames.length > 0 && objectInfotree[path]) {
                             fieldDefinition.referenceToInfos
                                 .filter((referenceToInfo) => requestedApiNames.includes(referenceToInfo.apiName))
                                 .forEach((ref) => {
-                                if (!objectInfoApiMap[path]) {
-                                    objectInfoApiMap[path] = [];
+                                if (!pathToObjectApiNamesMap[path]) {
+                                    pathToObjectApiNamesMap[path] = [];
                                 }
                                 // 'ServiceAppointment_Owner' ->['User', 'Group']
-                                if (!objectInfoApiMap[path].includes(ref.apiName)) {
-                                    objectInfoApiMap[path].push(ref.apiName);
+                                if (!pathToObjectApiNamesMap[path].includes(ref.apiName)) {
+                                    pathToObjectApiNamesMap[path].push(ref.apiName);
                                 }
                                 if (!apiNames.includes(ref.apiName)) {
                                     apiNames.push(ref.apiName);
@@ -51162,11 +51385,11 @@
                     }
                     else if (fieldDefinition.referenceToInfos.length === 1) {
                         const ref = fieldDefinition.referenceToInfos[0];
-                        if (!objectInfoApiMap[path]) {
-                            objectInfoApiMap[path] = [];
+                        if (!pathToObjectApiNamesMap[path]) {
+                            pathToObjectApiNamesMap[path] = [];
                         }
-                        if (!objectInfoApiMap[path].includes(ref.apiName)) {
-                            objectInfoApiMap[path].push(ref.apiName);
+                        if (!pathToObjectApiNamesMap[path].includes(ref.apiName)) {
+                            pathToObjectApiNamesMap[path].push(ref.apiName);
                         }
                         if (!apiNames.includes(ref.apiName)) {
                             apiNames.push(ref.apiName);
@@ -51177,11 +51400,11 @@
                     // handles 'childRelationship'
                     const childRelationship = parentObjectInfo.childRelationships.find((childRelationship) => childRelationship.relationshipName === field);
                     if (childRelationship) {
-                        if (!objectInfoApiMap[path]) {
-                            objectInfoApiMap[path] = [];
+                        if (!pathToObjectApiNamesMap[path]) {
+                            pathToObjectApiNamesMap[path] = [];
                         }
-                        if (!objectInfoApiMap[path].includes(childRelationship.childObjectApiName)) {
-                            objectInfoApiMap[path].push(childRelationship.childObjectApiName);
+                        if (!pathToObjectApiNamesMap[path].includes(childRelationship.childObjectApiName)) {
+                            pathToObjectApiNamesMap[path].push(childRelationship.childObjectApiName);
                         }
                         if (!apiNames.includes(childRelationship.childObjectApiName)) {
                             apiNames.push(childRelationship.childObjectApiName);
@@ -51203,10 +51426,10 @@
         }
         for (const nodeInfo of validObjectInfoNodes) {
             const field = nodeInfo.name;
-            const subLevelFields = objectInfotree[field];
-            const path = `${parentPath}_${field}`;
+            const path = `${parentPath}#${field}`;
+            const subLevelFields = objectInfotree[path];
             if (subLevelFields && subLevelFields.length > 0) {
-                const subObjectInfos = await fetchObjectInfos(objectInfotree, objectInfoApiMap, updatedObjectInfoMap, subLevelFields, path, objectInfoService);
+                const subObjectInfos = await fetchObjectInfos(objectInfotree, pathToObjectApiNamesMap, updatedObjectInfoMap, subLevelFields, path, objectInfoService);
                 updatedObjectInfoMap = { ...updatedObjectInfoMap, ...subObjectInfos };
             }
         }
@@ -51221,27 +51444,29 @@
      * 'path' and 'queryNode' is 1 level above the 'filterNode'
      * @param filterNode filter node which needs to be injected. For example, 'State' ObjectFieldNode  within filter 'where: { State: { eq: "Nova Scotia" }}'
      * @param idState ID state will be updated to determine if the ID fields in AST need to be swapped. The swapping happens later.
-     * @param path path to the current filterNode's parent. For example, path could be 'ServiceApointment' when filterNode is 'State'. If the path does not exist in 'objectInfoApiMap', parent node is not an field of relationship or recordQuery
+     * @param parentPath path to the current filterNode's parent. For example, path could be 'ServiceApointment' when filterNode is 'State'. If the path does not exist in 'pathToObjectApiNamesMap', parent node is not an field of relationship or recordQuery
+     * @param isParentPolymorphic true if parent points to a polymorphic field.
      * @param queryNode referece FieldNode which provides the information if 'filterNode' exist in it nor not.
      * @param objectInfos ObjectInfo map used in injection. If ObjectInfo misses or field does not exist in ObjectInfo, the error will be thrown
-     * @param objectInfoApiMap map used to locate the ObjectInfo. The key is path to a field, value is the ObjectInfo's apiName array. In the case of polymorphic fields, the apiName array have 2 or more elements. For example, 'ServiceAppointment' -> ['ServiceAppointment']; 'ServiceAppointment_Account' -> ['Account'], 'ServiceAppointment_Owner' -> ['User', 'Group'].
+     * @param pathToObjectApiNamesMap map used to locate the ObjectInfo. The key is path to a field, value is the ObjectInfo's apiName array. In the case of polymorphic fields, the apiName array have 2 or more elements. For example, 'ServiceAppointment' -> ['ServiceAppointment']; 'ServiceAppointment_Account' -> ['Account'], 'ServiceAppointment_Owner' -> ['User', 'Group'].
      * @param draftFunctions functions for working with record ids that may be draft-created ids
      * @returns an array of nodes with injected fields
      */
-    function injectFilter(filterNode, idState, path, objectInfos, objectInfoApiMap, draftFunctions, queryNode) {
+    function injectFilter(filterNode, idState, parentPath, isParentPolymorphic, objectInfos, pathToObjectApiNamesMap, draftFunctions, queryNode) {
         const injectedSelections = [];
+        let isPolymorphicField = false;
         switch (filterNode.kind) {
             case Kind.ARGUMENT:
                 if (filterNode.value.kind !== 'ObjectValue')
                     return [];
                 filterNode.value.fields.forEach((objectFieldNode) => {
-                    let subResults = injectFilter(objectFieldNode, idState, path, objectInfos, objectInfoApiMap, draftFunctions, queryNode);
+                    let subResults = injectFilter(objectFieldNode, idState, parentPath, isParentPolymorphic, objectInfos, pathToObjectApiNamesMap, draftFunctions, queryNode);
                     for (const subResult of subResults) {
                         mergeOrAddToGroup(injectedSelections, subResult);
                     }
                     // multiple Ids might need to be swapped. remember their paths for faster write.
                     if (idState.swapNeeded) {
-                        idState.paths.push(path);
+                        idState.paths.push(parentPath);
                     }
                 });
                 return injectedSelections;
@@ -51250,7 +51475,7 @@
                     case Kind.LIST: {
                         filterNode.value.values.filter(isObjectValueNode).forEach((objectValueNode) => {
                             objectValueNode.fields.forEach((objectFieldNode) => {
-                                const subResults = injectFilter(objectFieldNode, idState, path, objectInfos, objectInfoApiMap, draftFunctions, queryNode);
+                                const subResults = injectFilter(objectFieldNode, idState, parentPath, isParentPolymorphic, objectInfos, pathToObjectApiNamesMap, draftFunctions, queryNode);
                                 for (const subResult of subResults) {
                                     mergeOrAddToGroup(injectedSelections, subResult);
                                 }
@@ -51261,7 +51486,7 @@
                     case Kind.OBJECT: {
                         if (filterNode.name.value === 'not') {
                             filterNode.value.fields.forEach((objectFieldNode) => {
-                                const subResults = injectFilter(objectFieldNode, idState, path, objectInfos, objectInfoApiMap, draftFunctions, queryNode);
+                                const subResults = injectFilter(objectFieldNode, idState, parentPath, isParentPolymorphic, objectInfos, pathToObjectApiNamesMap, draftFunctions, queryNode);
                                 for (const subResult of subResults) {
                                     mergeOrAddToGroup(injectedSelections, subResult);
                                 }
@@ -51271,15 +51496,15 @@
                             let apiNames = [];
                             let isScalarField = false;
                             //It is possible that this is a polymorphic field
-                            apiNames = objectInfoApiMap[path];
-                            // example: path: 'ServiceAppointment_LastModifiedDate'; filterNode: '{eq: {literal: LAST_WEEK}}'. queryNode: 'LastModifedDate { value}' FilterNode's parent has been verifed as a valid node
+                            apiNames = pathToObjectApiNamesMap[parentPath];
+                            // example: path: 'ServiceAppointment#LastModifiedDate'; filterNode: '{eq: {literal: LAST_WEEK}}'. queryNode: 'LastModifedDate { value}' FilterNode's parent has been verifed as a valid node
                             if (apiNames === undefined) {
                                 isScalarField = true;
                             }
                             else {
                                 if (apiNames.some((apiName) => objectInfos[apiName] === undefined)) {
                                     // eslint-disable-next-line
-                                    throw new Error(`ObjectInfo is missing for ${path}`);
+                                    throw new Error(`ObjectInfo is missing for ${parentPath}`);
                                 }
                             }
                             if (isScalarField) {
@@ -51301,29 +51526,19 @@
                                     }
                                 });
                             let isSpanning = false;
+                            // if true, current node is a polymorphic concrete type node. For example, field node `User` under `Owner`
                             let isInlineFragment = false;
-                            let isPolymorphicField = false;
                             let isTypeNameExisting = false;
                             let curPath;
                             let fieldName = filterNode.name.value;
-                            curPath = `${path}_${fieldName}`;
-                            if (objectInfoApiMap[curPath] && objectInfoApiMap[curPath].length > 0) {
+                            curPath = `${parentPath}#${fieldName}`;
+                            if (pathToObjectApiNamesMap[curPath] &&
+                                pathToObjectApiNamesMap[curPath].length > 0) {
                                 isSpanning = true;
-                                if (objectInfoApiMap[curPath].length === 1) {
-                                    if (objectInfoApiMap[path] &&
-                                        objectInfoApiMap[path].length >= 1 &&
-                                        objectInfoApiMap[path].includes(objectInfoApiMap[curPath][0])) {
-                                        isInlineFragment = true;
-                                    }
-                                }
-                                // Checks if the current filter node is a polymorphic field. 'ServiceAppointment_Owner' --> ['User']; 'ServiceAppointment_Owner_User' --> ['User']
-                                const childApiName = objectInfoApiMap[curPath][0];
-                                const trialApiNames = objectInfoApiMap[`${curPath}_${childApiName}`];
-                                if (trialApiNames !== undefined &&
-                                    trialApiNames.length === 1 &&
-                                    trialApiNames[0] === childApiName) {
-                                    isPolymorphicField = true;
-                                }
+                                isInlineFragment =
+                                    isParentPolymorphic &&
+                                        pathToObjectApiNamesMap[curPath].length === 1;
+                                isPolymorphicField = isPolymorphicFieldPath(curPath, pathToObjectApiNamesMap, objectInfos);
                             }
                             // When filter node is at InLineFragment Level(a concrete entity of polymorphic field), query node is one level up. For example,  ObjectFieldNode is ...{User:{...}}, queryNode is Owner:[User]
                             if (isInlineFragment) {
@@ -51367,23 +51582,25 @@
                                     throw new Error(`Field ${fieldName} does not exist in ${apiNames[0]}`);
                                 }
                             }
-                            const objectInfoName = objectInfoApiMap[curPath] !== undefined
-                                ? objectInfoApiMap[curPath][0]
-                                : objectInfoApiMap[path][0];
+                            const objectInfoName = pathToObjectApiNamesMap[curPath] !== undefined
+                                ? pathToObjectApiNamesMap[curPath][0]
+                                : pathToObjectApiNamesMap[parentPath][0];
                             const isIdField = isFieldAnIdField(filterNode.name.value, objectInfos[objectInfoName]);
                             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, objectInfos, objectInfoApiMap, 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 &&
@@ -51412,6 +51629,7 @@
                                 }
                                 //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)) {
@@ -51542,6 +51760,44 @@
         }
         group.push(element);
     }
+    // checks if the path points to a polymorphic field. For example, for  the below `pathToObjectApiNamesMap`
+    //  {
+    //    'ServiceAppointment' -> ['ServiceAppointment']
+    //    'ServiceAppointment#Owner' --> ['User'],
+    //    'ServiceAppointment#Owner#User' --> ['User']
+    //  }
+    //  path `ServiceAppointment#Owner` points to a polymorphic field, but path `ServiceAppointment#Owner#User` does not.
+    function isPolymorphicFieldPath(path, pathToObjectApiNamesMap, objectInfos) {
+        const lastSegmentIndex = path.lastIndexOf('#');
+        if (lastSegmentIndex < 0) {
+            return false;
+        }
+        const lastSegment = path.slice(lastSegmentIndex + 1);
+        const parentApiPath = path.slice(0, lastSegmentIndex);
+        if (pathToObjectApiNamesMap[parentApiPath] === undefined) {
+            return false;
+        }
+        const parentObjectApiNames = pathToObjectApiNamesMap[parentApiPath];
+        // If the last segment is a Polymorphic field, its immediate parent is a concrete object entity, which has 1 objectApiName mapped to the parent path in `pathToObjectApiNamesMap`.
+        // For example, we like to check if `ServiceAppointment#Owner` path is polymorphic. The last segment is `Owner` and its parent `ServiceAppointment` has one element (which is also `ServiceAppointment`) array as its value.
+        // Below are the entries in `pathToObjectApiNamesMap`
+        //   {
+        //      `ServiceAppointmen`t: [`ServiceAppointment`],
+        //      `ServiceAppointment#Owner`: [`User`, `Group`],
+        //      `ServiceAppointment#Owner#User`: [`User`],
+        //      `ServiceAppointment#Owner#Group`: [`Group`],
+        //   }
+        if (parentObjectApiNames.length !== 1) {
+            return false;
+        }
+        const parentObjectInfo = objectInfos[parentObjectApiNames[0]];
+        const relationshipField = referenceIdFieldForRelationship(lastSegment);
+        let fieldDefinition = parentObjectInfo.fields[relationshipField];
+        if (fieldDefinition === undefined) {
+            return false;
+        }
+        return fieldDefinition.polymorphicForeignKey;
+    }
     function isFieldAnIdField(fieldName, objectInfo) {
         if (fieldName === 'Id')
             return true;
@@ -51594,10 +51850,10 @@
      * @param parentNode parent node of param 1
      * @param ancestors ancester of param 1
      * @param objectInfos ObjectInfo map used in injection. If ObjectInfo misses or field does not exist in ObjectInfo, the error will be thrown
-     * @param objectInfoApiMap map used to locate the ObjectInfo. The key is path to a field, value is the ObjectInfo's apiName array. In the case of polymorphic fields, the apiName array have 2 or more elements. For example, 'ServiceAppointment' -> ['ServiceAppointment']; 'ServiceAppointment_Account' -> ['Account'], 'ServiceAppointment_Owner' -> ['User', 'Group'].
+     * @param pathToObjectApiNamesMap map used to locate the ObjectInfo. The key is path to a field, value is the ObjectInfo's apiName array. In the case of polymorphic fields, the apiName array have 2 or more elements. For example, 'ServiceAppointment' -> ['ServiceAppointment']; 'ServiceAppointment#Account' -> ['Account'], 'ServiceAppointment#Owner' -> ['User', 'Group'].
      * @return injected SelectionNodes used to construct the InlineFragment.
      */
-    function injectFields(selections, parentNode, ancestors, objectInfos, objectInfoApiMap) {
+    function injectFields(selections, parentNode, parentPath, ancestors, objectInfos, pathToObjectApiNamesMap) {
         /**
          *  1 parentship can return 2 FieldNode which need to be flattened
          *  Concact: {   **   Contact {    ** ContactId {
@@ -51615,6 +51871,10 @@
             if (!selection.selectionSet) {
                 return selection;
             }
+            const segment = isFieldNode(selection)
+                ? selection.name.value
+                : selection.typeCondition.name.value;
+            const curPath = `${parentPath}#${segment}`;
             const spanningSubSelections = [];
             for (const subSelection of selection.selectionSet.selections) {
                 if (isFieldSpanning(subSelection, selection)) {
@@ -51622,7 +51882,7 @@
                 }
             }
             // Handles multiple level field injection like 'ServiceAppointment' --> 'Account' --> 'Owner'
-            const subInjectedSelections = injectFields(spanningSubSelections, selection, ancestors, objectInfos, objectInfoApiMap);
+            const subInjectedSelections = injectFields(spanningSubSelections, selection, curPath, ancestors, objectInfos, pathToObjectApiNamesMap);
             if (!selection.selectionSet) {
                 return selection;
             }
@@ -51665,7 +51925,7 @@
                 }
             }
             // For polymorphic fields, the Id field is excluded.
-            const excludeId = selection.selectionSet.selections.every(isInlineFragmentNode);
+            const excludeId = isPolymorphicFieldPath(curPath, pathToObjectApiNamesMap, objectInfos);
             const idSelection = [];
             if (!excludeId && !hasIdAlready) {
                 idSelection.push({
@@ -51676,8 +51936,8 @@
                     },
                 });
             }
-            // Inject '__typename' for polymorphic fields. '__typename' field acts as a reference to concrete type of a polymorphic field and is used to match JSON response with AST node. For more detail,
-            // please reference 'removeSyntheticFields'.
+            // Inject '__typename' for InlineFragment. '__typename' field acts as a reference to concrete type of a polymorphic field or a standard field in the returned GQL response, which equals to
+            // `typedCondition` of the InlineFragment in the query AST. It is used to match JSON response with AST node. For more detail, please reference 'removeSyntheticFields'.
             if (isInlineFragmentNode(selection) &&
                 !selection.selectionSet.selections.find((selection) => isFieldNode(selection) && selection.name.value === '__typename')) {
                 idSelection.push({
@@ -51711,7 +51971,7 @@
         if (isFieldNode(parentNode) && parentNode.selectionSet && parentNode.name.value === 'node') {
             if (parentNode.selectionSet.selections
                 .filter(isFieldOrInlineFragmentNode)
-                .some((selectionNode) => isRelationship(selectionNode, 'childRelationship'))) {
+                .some((selectionNode) => isRelationship(selectionNode, CHILD_RELATIONSHIP))) {
                 if (!parentNode.selectionSet.selections
                     .filter(isFieldNode)
                     .some((sibling) => sibling.name.value === 'Id')) {
@@ -51730,15 +51990,15 @@
                 if (parentInfo.parentIndex >= 0) {
                     // example node { TimeSheetEntries { edges { node { Id }}}}
                     const parent = parentInfo.node;
-                    if (isRelationship(parent, 'childRelationship')) {
+                    if (isRelationship(parent, CHILD_RELATIONSHIP)) {
                         const unVisitedAncestors = ancestors.slice(0, parentInfo.parentIndex);
                         // path : "TimeSheet"
                         const grandParentPath = findAncesterPath(unVisitedAncestors);
-                        if (objectInfoApiMap &&
-                            objectInfoApiMap[grandParentPath] &&
+                        if (pathToObjectApiNamesMap &&
+                            pathToObjectApiNamesMap[grandParentPath] &&
                             objectInfos &&
-                            objectInfos[objectInfoApiMap[grandParentPath][0]]) {
-                            const grandParentObjectInfo = objectInfos[objectInfoApiMap[grandParentPath][0]];
+                            objectInfos[pathToObjectApiNamesMap[grandParentPath][0]]) {
+                            const grandParentObjectInfo = objectInfos[pathToObjectApiNamesMap[grandParentPath][0]];
                             // exmaple "TimeSheetEntries"
                             const parentFieldName = parent.name.value;
                             const targetRelationship = grandParentObjectInfo.childRelationships.find((childRelationship) => {
@@ -51859,7 +52119,7 @@
                             },
                             value: {
                                 kind: 'StringValue',
-                                value: 'childRelationship',
+                                value: CHILD_RELATIONSHIP,
                                 block: false,
                             },
                         },
@@ -51951,7 +52211,7 @@
                                                                 },
                                                                 value: {
                                                                     kind: 'StringValue',
-                                                                    value: 'parentRelationship',
+                                                                    value: PARENT_RELATIONSHIP,
                                                                     block: false,
                                                                 },
                                                             },
@@ -52088,7 +52348,9 @@
                 jsonOutput[fieldName] = null;
                 return;
             }
-            jsonOutput[fieldName] = {};
+            if (jsonOutput[fieldName] === undefined) {
+                jsonOutput[fieldName] = {};
+            }
             createUserJsonOutput(selection, jsonInput[fieldName], jsonOutput[fieldName]);
         }
         else {
@@ -52820,34 +53082,42 @@
             }
             const { dataType, relationshipName, referenceToInfos } = fieldInfo;
             const draftFieldValue = record.fields[draftField].value;
-            if (dataType === 'Reference' && relationshipName !== null && draftFieldValue !== null) {
-                if (typeof draftFieldValue !== 'string') {
-                    throw Error('reference field value is not a string');
+            if (dataType === 'Reference' && relationshipName !== null) {
+                if (draftFieldValue === null) {
+                    recordFields[relationshipName] = {
+                        displayValue: null,
+                        value: null,
+                    };
                 }
-                const key = getRecordKeyForId(luvio, draftFieldValue);
-                const referencedRecord = referencedRecords.get(key);
-                recordFields[relationshipName] = {
-                    displayValue: null,
-                    value: createLink$2(key),
-                };
-                // for custom objects, we select the 'Name' field
-                // otherwise we check the object info for name fields.
-                //if there are multiple we select 'Name' if it exists, otherwise the first one
-                if (referencedRecord !== undefined && referenceToInfos.length > 0) {
-                    let nameField;
-                    const referenceToInfo = referenceToInfos[0];
-                    const nameFields = referenceToInfo.nameFields;
-                    if (nameFields.length !== 0) {
-                        nameField = nameFields.find((x) => x === 'Name');
-                        if (nameField === undefined) {
-                            nameField = nameFields[0];
-                        }
+                else {
+                    if (typeof draftFieldValue !== 'string') {
+                        throw Error('reference field value is not a string');
                     }
-                    if (nameField !== undefined) {
-                        const nameFieldRef = referencedRecord.fields[nameField];
-                        if (nameFieldRef) {
-                            recordFields[relationshipName].displayValue =
-                                (_a = nameFieldRef.displayValue) !== null && _a !== void 0 ? _a : nameFieldRef.value;
+                    const key = getRecordKeyForId(luvio, draftFieldValue);
+                    const referencedRecord = referencedRecords.get(key);
+                    recordFields[relationshipName] = {
+                        displayValue: null,
+                        value: createLink$2(key),
+                    };
+                    // for custom objects, we select the 'Name' field
+                    // otherwise we check the object info for name fields.
+                    //if there are multiple we select 'Name' if it exists, otherwise the first one
+                    if (referencedRecord !== undefined && referenceToInfos.length > 0) {
+                        let nameField;
+                        const referenceToInfo = referenceToInfos[0];
+                        const nameFields = referenceToInfo.nameFields;
+                        if (nameFields.length !== 0) {
+                            nameField = nameFields.find((x) => x === 'Name');
+                            if (nameField === undefined) {
+                                nameField = nameFields[0];
+                            }
+                        }
+                        if (nameField !== undefined) {
+                            const nameFieldRef = referencedRecord.fields[nameField];
+                            if (nameFieldRef) {
+                                recordFields[relationshipName].displayValue =
+                                    (_a = nameFieldRef.displayValue) !== null && _a !== void 0 ? _a : nameFieldRef.value;
+                            }
                         }
                     }
                 }
@@ -53140,17 +53410,8 @@
             };
             for (const fieldName of keys$3(recordWithSpanningRefLinks.fields)) {
                 const fieldKey = buildRecordFieldStoreKey(key, fieldName);
-                if (this.collectedFields[fieldKey] !== undefined) {
-                    const fieldData = recordWithSpanningRefLinks.fields[fieldName];
-                    normalizedRecord.fields[fieldName] = { __ref: fieldKey };
-                    publishData(fieldKey, fieldData);
-                }
-                else if (recordWithSpanningRefLinks.fields[fieldName] &&
-                    recordWithSpanningRefLinks.fields[fieldName].value &&
-                    recordWithSpanningRefLinks.fields[fieldName].value.__ref !== undefined) {
-                    normalizedRecord.fields[fieldName] = { __ref: fieldKey };
-                    publishData(fieldKey, recordWithSpanningRefLinks.fields[fieldName]);
-                }
+                normalizedRecord.fields[fieldName] = { __ref: fieldKey };
+                publishData(fieldKey, recordWithSpanningRefLinks.fields[fieldName]);
             }
             // publish the normalized record
             publishData(key, normalizedRecord);
@@ -54049,6 +54310,9 @@
                 if (!rebuildResult.errors) {
                     rebuildResult = removeSyntheticFields(rebuildResult, config.query);
                 }
+                if (objectsDeepEqual(rebuildResult, originalSnapshot.data)) {
+                    return originalSnapshot;
+                }
                 // 'originalSnapshot' is the local eval snapshot subscribed. It is always in 'Fulfilled' state. This behavior would change once W-1273462(rebuild non-evaluated snapshot when the graphql local eval rebuild is triggered) is resolved.
                 return {
                     ...originalSnapshot,
@@ -54067,7 +54331,7 @@
             // 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,
@@ -54076,6 +54340,22 @@
                     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;
         };
     }
 
@@ -55129,7 +55409,10 @@
      * @returns the merged record
      */
     function mergeAggregateUiResponse(response, mergeFunc) {
-        const { body } = response;
+        if (response.ok === false) {
+            return response;
+        }
+        const body = response.body;
         try {
             if (body === null ||
                 body === undefined ||
@@ -56960,6 +57243,9 @@
             this.ldsRecordRefresher = config.ldsRecordRefresher;
             this.networkWorkerPool = new AsyncWorkerPool(this.concurrency);
             this.useBatchGQL = ldsPrimingGraphqlBatch.isOpen({ fallback: false });
+            if (this.useBatchGQL) {
+                this.batchSize = this.batchSize / DEFAULT_GQL_QUERY_BATCH_SIZE;
+            }
             this.conflictPool = new ConflictPool(config.store, this.objectInfoLoader);
         }
         // function that enqueues priming work
@@ -57816,7 +58102,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$1,
     });
-    // version: 1.228.1-4e6356f71
+    // version: 1.229.0-dev10-bc9ef2513
 
     const { create: create$2, keys: keys$2 } = Object;
     const { stringify: stringify$1, parse: parse$1 } = JSON;
@@ -71140,7 +71426,7 @@
         }
     }
 
-    const { assign, create: create$1, freeze: freeze$1, keys: keys$1 } = Object;
+    const { assign, create: create$1, freeze: freeze$1, isFrozen, keys: keys$1 } = Object;
     const { isArray: isArray$1 } = Array;
     const { concat, filter, includes, push, reduce } = Array.prototype;
 
@@ -72579,6 +72865,7 @@
         }
         if (fieldData === null) {
             reader.assignScalar(requestedFieldName, sink, fieldData);
+            reader.exitPath();
             return sink;
         }
         const fieldType = getFieldType(sel);
@@ -72604,17 +72891,8 @@
         return sink;
     }
     function selectTypeLink(sel, fieldData, reader, key, sink, variables, fragments, version, selectFn, isCursorConnection) {
-        const resolvedLink = reader.read({
-            recordId: fieldData.__ref,
-            node: {
-                kind: 'Fragment',
-                private: [],
-                opaque: true,
-                version,
-            },
-            variables: {}
-        });
-        if (resolvedLink.data !== undefined) {
+        const resolvedLink = resolveLink$1(reader, fieldData, version);
+        if (resolvedLink && resolvedLink.data !== undefined) {
             if (isCursorConnection) {
                 selectTypeLinkWithPagination(resolvedLink, sel, fieldData, reader, key, sink, variables, fragments, selectFn);
             }
@@ -73190,19 +73468,11 @@
             }
             case 'PolymorphicParentRelationship':
             case 'RecordRepresentation': {
-                const spanningFieldLink = reader.read({
-                    recordId: fieldData.__ref,
-                    node: {
-                        kind: 'Fragment',
-                        private: [],
-                        opaque: true,
-                        version: VERSION$f,
-                    },
-                    variables: {},
-                });
-                reader.markSeenId(fieldData.__ref);
-                const resolvedSpanningFieldValue = spanningFieldLink.data;
+                const spanningFieldLink = resolveLink$1(reader, fieldData, VERSION$f);
+                const resolvedSpanningFieldValue = spanningFieldLink && spanningFieldLink.data;
+                const fieldDataRef = fieldData.__ref;
                 if (resolvedSpanningFieldValue !== undefined) {
+                    reader.markSeenId(fieldDataRef);
                     const { value: spanningFieldResult } = resolvedSpanningFieldValue;
                     // Handle null values - graphql will return it at the field level, not return nested { value: null }
                     if (spanningFieldResult === null || typeof spanningFieldResult !== 'object') {
@@ -73226,7 +73496,9 @@
                     }
                 }
                 else {
-                    reader.markMissingLink(fieldData.__ref);
+                    if (fieldDataRef !== undefined) {
+                        reader.markMissingLink(fieldDataRef);
+                    }
                     reader.markMissing();
                 }
                 break;
@@ -76262,7 +76534,7 @@
         configuration: { ...configurationForGraphQLAdapters },
         instrument,
     });
-    // version: 1.228.1-0cb6f94f1
+    // version: 1.229.0-dev10-abb060196
 
     // On core the unstable adapters are re-exported with different names,
 
@@ -78509,7 +78781,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.228.1-0cb6f94f1
+    // version: 1.229.0-dev10-abb060196
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -79240,4 +79512,4 @@
     Object.defineProperty(exports, '__esModule', { value: true });
 
 }));
-// version: 1.228.1-4e6356f71
+// version: 1.229.0-dev10-bc9ef2513