@salesforce/lds-worker-api 1.229.0-dev1 → 1.229.0-dev3

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

@@ -3841,7 +3841,7 @@ function createResourceParamsImpl(config, configMetadata) {
     }
     return resourceParams;
 }
-// engine version: 0.145.2-6a13677c
+// engine version: 0.146.0-dev3-502c4337
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -3968,7 +3968,7 @@ function withDefaultLuvio(callback) {
     }
     callbacks.push(callback);
 }
-// version: 1.229.0-dev1-f69d054a9
+// version: 1.229.0-dev3-175ac936b
 
 // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
 function instrumentAdapter$1(createFunction, _metadata) {
@@ -15429,7 +15429,7 @@ function gql(literals, ...subs) {
     }
     return superResult;
 }
-// version: 1.229.0-dev1-f69d054a9
+// version: 1.229.0-dev3-175ac936b
 
 function unwrap(data) {
     // The lwc-luvio bindings import a function from lwc called "unwrap".
@@ -15530,14 +15530,15 @@ function refreshData(data, dataToTuple, luvio) {
         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.
  *
@@ -16352,7 +16353,7 @@ function createGraphQLWireAdapterConstructor(luvio, adapter, metadata, astResolv
     const { apiFamily, name } = metadata;
     return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
 }
-// version: 1.229.0-dev1-f69d054a9
+// version: 1.229.0-dev3-175ac936b
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -16451,7 +16452,7 @@ var TypeCheckShapes;
     TypeCheckShapes[TypeCheckShapes["Integer"] = 3] = "Integer";
     TypeCheckShapes[TypeCheckShapes["Unsupported"] = 4] = "Unsupported";
 })(TypeCheckShapes || (TypeCheckShapes = {}));
-// engine version: 0.145.2-6a13677c
+// engine version: 0.146.0-dev3-502c4337
 
 const { keys: ObjectKeys$3, create: ObjectCreate$3 } = Object;
 
@@ -25038,18 +25039,28 @@ const buildLayoutModeCacheSnapshot = (apiName, recordTypeId, layoutType, mode) =
  * 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',
+                },
+            });
+        });
     });
 }
 /**
@@ -41158,7 +41169,7 @@ withDefaultLuvio((luvio) => {
     throttle(60, 60000, createLDSAdapter(luvio, 'notifyListInfoUpdateAvailable', notifyUpdateAvailableFactory$1));
     throttle(60, 60000, createLDSAdapter(luvio, 'notifyQuickActionDefaultsUpdateAvailable', notifyUpdateAvailableFactory));
 });
-// version: 1.229.0-dev1-5b6d3db67
+// version: 1.229.0-dev3-71194d134
 
 var caseSensitiveUserId = '005B0000000GR4OIAW';
 
@@ -41789,6 +41800,9 @@ function handleDurableStoreRejection(instrument) {
 }
 
 function isStoreEntryError(storeRecord) {
+    if (!storeRecord || typeof storeRecord !== 'object') {
+        return false;
+    }
     return storeRecord.__type === 'error';
 }
 
@@ -45497,8 +45511,8 @@ function rootRecordQuery(selection, input) {
         // 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;
+            // subtract 1000ms from timestamp to account for ingestion processing time
+            input.rootTimestamp = queryMetadata.ingestionTimestamp - 1000;
         }
     }
     return recordQuery(selection, alias, apiName, [], input);
@@ -49280,6 +49294,10 @@ function isOperationDefinitionNode(node) {
     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;
@@ -49295,18 +49313,41 @@ function isRecordQuery(recordQueryField) {
                 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--) {
@@ -49320,9 +49361,11 @@ function findNearestAncesterPath(ancestors, recordQueryOnly) {
                 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;
@@ -49337,17 +49380,19 @@ function findNearestAncesterPath(ancestors, recordQueryOnly) {
     //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;
@@ -49371,7 +49416,7 @@ function findAncesterPath(ancesters) {
                         ? sectionPath
                         : sectionPath === ''
                             ? path
-                            : `${sectionPath}_${path}`;
+                            : `${sectionPath}#${path}`;
             }
         }
         boundaryIndex = parentIndex;
@@ -49429,9 +49474,9 @@ function getRelation(node) {
         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];
@@ -49488,8 +49533,8 @@ function isFieldSpanning(node, parentNode) {
  */
 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
@@ -50322,8 +50367,8 @@ async function fetchIngestionTimeStampFromDatabase(apiName, info, args, query) {
         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;
+            //go back 1000 ms to adjust for margin of error when top level query is stored and when raml objects are stored
+            ingestionTimestamp = timestamp - 1000;
         }
     }
     return ingestionTimestamp;
@@ -50372,26 +50417,20 @@ function generateRecordQueries(objectInfos) {
     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;
@@ -50399,11 +50438,13 @@ function generateRecordQueries(objectInfos) {
                 // 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) {
@@ -50412,6 +50453,20 @@ function generateRecordQueries(objectInfos) {
                 }
             }
         }
+        // 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 */ `
@@ -50571,7 +50626,7 @@ const parentRelationshipDirective = {
             },
             value: {
                 kind: Kind.STRING,
-                value: 'parentRelationship',
+                value: PARENT_RELATIONSHIP,
                 block: false,
             },
         },
@@ -50585,8 +50640,8 @@ async function injectSyntheticFields(originalAST, objectInfoService, draftFuncti
     // 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 = {};
@@ -50600,11 +50655,11 @@ async function injectSyntheticFields(originalAST, objectInfoService, draftFuncti
     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':
@@ -50612,12 +50667,12 @@ async function injectSyntheticFields(originalAST, objectInfoService, draftFuncti
                         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)) {
@@ -50632,17 +50687,16 @@ async function injectSyntheticFields(originalAST, objectInfoService, draftFuncti
                                 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:
@@ -50656,7 +50710,7 @@ async function injectSyntheticFields(originalAST, objectInfoService, draftFuncti
                     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);
@@ -50667,21 +50721,21 @@ async function injectSyntheticFields(originalAST, objectInfoService, draftFuncti
         },
     });
     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]
@@ -50695,7 +50749,7 @@ async function injectSyntheticFields(originalAST, objectInfoService, draftFuncti
                     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);
                             }
@@ -50721,7 +50775,7 @@ async function injectSyntheticFields(originalAST, objectInfoService, draftFuncti
                     case 'where': {
                         inlineFragmentSelections[ancestorPath] = [
                             ...inlineFragmentSelections[ancestorPath],
-                            ...injectFilter(node, idState, ancestorPath, objectInfos, objectInfoApiMap, draftFunctions, recordReferenceNode),
+                            ...injectFilter(node, idState, ancestorPath, false, objectInfos, pathToObjectApiNamesMap, draftFunctions, recordReferenceNode),
                         ];
                         break;
                     }
@@ -50737,7 +50791,7 @@ async function injectSyntheticFields(originalAST, objectInfoService, draftFuncti
                 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);
@@ -50749,7 +50803,7 @@ async function injectSyntheticFields(originalAST, objectInfoService, draftFuncti
                         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;
             },
@@ -50762,7 +50816,7 @@ async function injectSyntheticFields(originalAST, objectInfoService, draftFuncti
                 // 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;
                     }
@@ -50771,7 +50825,7 @@ async function injectSyntheticFields(originalAST, objectInfoService, draftFuncti
                     return;
                 if (!node.selectionSet)
                     return;
-                const recordQueryField = findNearestRecordQuery(ancestors);
+                const recordQueryField = findNearestConnection(ancestors);
                 if (!recordQueryField)
                     return;
                 const ancestorPath = findAncesterPath(ancestors);
@@ -50780,8 +50834,8 @@ async function injectSyntheticFields(originalAST, objectInfoService, draftFuncti
                     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,
@@ -50818,7 +50872,7 @@ async function injectSyntheticFields(originalAST, objectInfoService, draftFuncti
                 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 {
@@ -50884,8 +50938,8 @@ function swapIdField(filterFields, objectInfo, swapped, idState, draftFunctions)
             };
     }
 }
-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]];
@@ -50974,15 +51028,16 @@ function growObjectFieldTree(tree, parentNode, entryNode, totalNodes, startNodes
                     }
                     // 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);
                 }
             }
         }
@@ -51017,19 +51072,20 @@ function growFieldTree(tree, parentSectionPath, entryNode, parentNode, totalNode
                 }
                 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);
                     }
                 }
             }
@@ -51059,23 +51115,23 @@ function growFieldTree(tree, parentSectionPath, entryNode, parentNode, totalNode
                     }
                     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);
             }
         }
     }
@@ -51087,7 +51143,7 @@ function growFieldTree(tree, parentSectionPath, entryNode, parentNode, totalNode
  * @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));
@@ -51101,9 +51157,9 @@ async function resolveObjectInfos(objectInfotree, objectInfoApiMap, startNodes,
         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;
@@ -51111,15 +51167,15 @@ async function resolveObjectInfos(objectInfotree, objectInfoApiMap, startNodes,
 // 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)) {
@@ -51131,8 +51187,8 @@ async function fetchObjectInfos(objectInfotree, objectInfoApiMap, objectInfoMap,
                 // 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 };
@@ -51147,7 +51203,7 @@ async function fetchObjectInfos(objectInfotree, objectInfoApiMap, objectInfoMap,
         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);
@@ -51165,21 +51221,21 @@ async function fetchObjectInfos(objectInfotree, objectInfoApiMap, objectInfoMap,
                     }
                 }
                 // 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);
@@ -51189,11 +51245,11 @@ async function fetchObjectInfos(objectInfotree, objectInfoApiMap, objectInfoMap,
                 }
                 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);
@@ -51204,11 +51260,11 @@ async function fetchObjectInfos(objectInfotree, objectInfoApiMap, objectInfoMap,
                 // 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);
@@ -51230,10 +51286,10 @@ async function fetchObjectInfos(objectInfotree, objectInfoApiMap, objectInfoMap,
     }
     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 };
         }
     }
@@ -51248,27 +51304,29 @@ async function fetchObjectInfos(objectInfotree, objectInfoApiMap, objectInfoMap,
  * '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;
@@ -51277,7 +51335,7 @@ function injectFilter(filterNode, idState, path, objectInfos, objectInfoApiMap,
                 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);
                             }
@@ -51288,7 +51346,7 @@ function injectFilter(filterNode, idState, path, objectInfos, objectInfoApiMap,
                 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);
                             }
@@ -51298,15 +51356,15 @@ function injectFilter(filterNode, idState, path, objectInfos, objectInfoApiMap,
                         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) {
@@ -51328,29 +51386,19 @@ function injectFilter(filterNode, idState, path, objectInfos, objectInfoApiMap,
                                 }
                             });
                         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) {
@@ -51394,9 +51442,9 @@ function injectFilter(filterNode, idState, path, objectInfos, objectInfoApiMap,
                                 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 = [];
@@ -51408,7 +51456,7 @@ function injectFilter(filterNode, idState, path, objectInfos, objectInfoApiMap,
                                     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);
+                                let subResults = injectFilter(subFieldNode, idState, curPath, isPolymorphicField, objectInfos, pathToObjectApiNamesMap, draftFunctions, existingFields ? existingFields[0] : undefined);
                                 subSelectionNodes = subSelectionNodes.concat(subResults);
                             });
                             if (!subFieldsHasId) {
@@ -51569,6 +51617,44 @@ function mergeOrAddToGroup(group, element) {
     }
     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;
@@ -51621,10 +51707,10 @@ function updateIDInfo(fieldNode, idState, draftFunctions) {
  * @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 {
@@ -51642,6 +51728,10 @@ function injectFields(selections, parentNode, ancestors, objectInfos, objectInfo
         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)) {
@@ -51649,7 +51739,7 @@ function injectFields(selections, parentNode, ancestors, objectInfos, objectInfo
             }
         }
         // 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;
         }
@@ -51692,7 +51782,7 @@ function injectFields(selections, parentNode, ancestors, objectInfos, objectInfo
             }
         }
         // 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({
@@ -51703,8 +51793,8 @@ function injectFields(selections, parentNode, ancestors, objectInfos, objectInfo
                 },
             });
         }
-        // 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({
@@ -51738,7 +51828,7 @@ function injectFields(selections, parentNode, ancestors, objectInfos, objectInfo
     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')) {
@@ -51757,15 +51847,15 @@ function injectFields(selections, parentNode, ancestors, objectInfos, objectInfo
             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) => {
@@ -51886,7 +51976,7 @@ const assignedToMeFragmentSelections = [
                         },
                         value: {
                             kind: 'StringValue',
-                            value: 'childRelationship',
+                            value: CHILD_RELATIONSHIP,
                             block: false,
                         },
                     },
@@ -51978,7 +52068,7 @@ const assignedToMeFragmentSelections = [
                                                             },
                                                             value: {
                                                                 kind: 'StringValue',
-                                                                value: 'parentRelationship',
+                                                                value: PARENT_RELATIONSHIP,
                                                                 block: false,
                                                             },
                                                         },
@@ -52115,7 +52205,9 @@ function handleNonArrayJsonProperty(selection, fieldName, jsonInput, jsonOutput)
             jsonOutput[fieldName] = null;
             return;
         }
-        jsonOutput[fieldName] = {};
+        if (jsonOutput[fieldName] === undefined) {
+            jsonOutput[fieldName] = {};
+        }
         createUserJsonOutput(selection, jsonInput[fieldName], jsonOutput[fieldName]);
     }
     else {
@@ -56990,6 +57082,9 @@ class PrimingSession extends EventEmitter {
         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
@@ -57846,7 +57941,7 @@ register({
     id: '@salesforce/lds-network-adapter',
     instrument: instrument$1,
 });
-// version: 1.229.0-dev1-f69d054a9
+// version: 1.229.0-dev3-175ac936b
 
 const { create: create$2, keys: keys$2 } = Object;
 const { stringify: stringify$1, parse: parse$1 } = JSON;
@@ -72609,6 +72704,7 @@ function buildSelectionForField$7(source, reader, sel, variables, fragments, isC
     }
     if (fieldData === null) {
         reader.assignScalar(requestedFieldName, sink, fieldData);
+        reader.exitPath();
         return sink;
     }
     const fieldType = getFieldType(sel);
@@ -76292,7 +76388,7 @@ register({
     configuration: { ...configurationForGraphQLAdapters },
     instrument,
 });
-// version: 1.229.0-dev1-5b6d3db67
+// version: 1.229.0-dev3-71194d134
 
 // On core the unstable adapters are re-exported with different names,
 
@@ -78539,7 +78635,7 @@ withDefaultLuvio((luvio) => {
     unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
     graphQLImperative = ldsAdapter;
 });
-// version: 1.229.0-dev1-5b6d3db67
+// version: 1.229.0-dev3-71194d134
 
 var gqlApi = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -79253,4 +79349,4 @@ const { luvio } = getRuntime();
 setDefaultLuvio({ luvio });
 
 export { createPrimingSession, draftManager, draftQueue, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, invokeAdapter, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, registerReportObserver, setMetadataTTL, setUiApiRecordTTL, subscribeToAdapter };
-// version: 1.229.0-dev1-f69d054a9
+// version: 1.229.0-dev3-175ac936b