@salesforce/lds-worker-api 1.377.1 → 1.378.0

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

@@ -4280,7 +4280,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.377.1-dadb6358f3
+    // version: 1.378.0-0ab3d40d29
 
     // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
     function instrumentAdapter$1(createFunction, _metadata) {
@@ -5324,7 +5324,7 @@
         const { apiFamily, name } = metadata;
         return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
     }
-    // version: 1.377.1-dadb6358f3
+    // version: 1.378.0-0ab3d40d29
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -34160,7 +34160,7 @@
         throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
         throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
     });
-    // version: 1.377.1-db77d3f339
+    // version: 1.378.0-63d7c07562
 
     function requestIdleDetectedCallback(_callback) { }
     function declareNotifierTaskSingle(_name) {
@@ -87035,9 +87035,9 @@
                             }
                             // spanning field needs to have the directive with 'parentRelationship'
                             const directives = isSpanning && !isInlineFragment ? [parentRelationshipDirective] : [];
-                            let idField = isSpanning && !isPolymorphicField ? [createFieldNode$1('Id')] : [];
+                            let idField = isSpanning && !isPolymorphicField ? [createFieldNode('Id')] : [];
                             // This variable change to InlineFragment if 'isInlineFragment' is true
-                            let sel = createFieldNode$1(fieldName);
+                            let sel = createFieldNode(fieldName);
                             // Check if fields is valid
                             if (apiNames.length === 1 && !isInlineFragment) {
                                 const objectInfo = objectInfos[apiNames[0]];
@@ -87083,7 +87083,7 @@
                                     idField = [];
                                 }
                                 if (isInlineFragment && !isTypeNameExisting) {
-                                    idField.push(createFieldNode$1('__typename'));
+                                    idField.push(createFieldNode('__typename'));
                                 }
                                 //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 ||
@@ -87150,7 +87150,7 @@
                                         .filter(isFieldNode)
                                         .filter((subNode) => subNode.name.value === relationField);
                                 if (!existingRelationFields || existingRelationFields.length === 0) {
-                                    injectedSelections.push(createFieldNode$1(relationField, FieldValueNodeSelectionSet));
+                                    injectedSelections.push(createFieldNode(relationField, FieldValueNodeSelectionSet));
                                 }
                             }
                         }
@@ -87241,7 +87241,7 @@
                 .filter(isFieldNode)
                 .filter((subNode) => subNode.name.value === 'value');
         return !existingValueFields || existingValueFields.length === 0
-            ? [createFieldNode$1('value')]
+            ? [createFieldNode('value')]
             : [];
     }
     function updateIDInfo(fieldNode, idState, draftFunctions) {
@@ -87322,20 +87322,20 @@
                         .filter(isFieldNode)
                         .filter((subNode) => subNode.name.value === relationshipId);
                     if (existingRelationFields.length === 0) {
-                        parentInjectedNodes.push(createFieldNode$1(relationshipId, FieldValueNodeSelectionSet));
+                        parentInjectedNodes.push(createFieldNode(relationshipId, FieldValueNodeSelectionSet));
                     }
                 }
                 // For polymorphic fields, the Id field is excluded.
                 const excludeId = isPolymorphicFieldPath(curPath, pathToObjectApiNamesMap, objectInfos);
                 const idSelection = [];
                 if (!excludeId && hasIdNode === false) {
-                    idSelection.push(createFieldNode$1('Id'));
+                    idSelection.push(createFieldNode('Id'));
                 }
                 // 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(createFieldNode$1('__typename'));
+                    idSelection.push(createFieldNode('__typename'));
                 }
                 // 'ServiceAppointment' --> 'Contact' --> 'Id', Inject 'Contact' with Id. 'Id' field is at the sub level.
                 if (idSelection.length > 0 || subInjectedSelections.length > 0) {
@@ -87379,7 +87379,7 @@
                 objectInfo.nameFields !== undefined &&
                 objectInfo.nameFields.length > 0) {
                 displayValueNameFields = objectInfo.nameFields.map((fieldName) => {
-                    return createFieldNode$1(fieldName, FieldValueNodeSelectionSet);
+                    return createFieldNode(fieldName, FieldValueNodeSelectionSet);
                 });
             }
         }
@@ -87410,7 +87410,7 @@
             if (parentNode.name.value === 'node') {
                 const idNode = findIdFieldNode(parentNode);
                 if (idNode === false) {
-                    rootQueryIdField.push(createFieldNode$1('Id'));
+                    rootQueryIdField.push(createFieldNode('Id'));
                 }
             }
             // example { node { Id } }. The operation happens at the 'edges' -> 'node'  level of the 'childRelationship' field
@@ -87438,7 +87438,7 @@
                                 .filter(isFieldNode)
                                 .some((sibling) => sibling.name.value === injectedParentFieldName)) {
                                 // example: TimeSheetId { value }
-                                relatedIdForChildRelationship.push(createFieldNode$1(injectedParentFieldName, FieldValueNodeSelectionSet));
+                                relatedIdForChildRelationship.push(createFieldNode(injectedParentFieldName, FieldValueNodeSelectionSet));
                             }
                             displayValueNameFields.push(...injectFieldsForDisplayValue(parentNode, targetRelationship.childObjectApiName, objectInfos));
                         }
@@ -87890,7 +87890,7 @@
      * @param selectionSet
      * @returns
      */
-    function createFieldNode$1(nameValue, selectionSet) {
+    function createFieldNode(nameValue, selectionSet) {
         return {
             kind: Kind$3.FIELD,
             name: {
@@ -95887,7 +95887,7 @@
             },
         };
     }
-    // version: 1.377.1-db77d3f339
+    // version: 1.378.0-63d7c07562
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -95913,7 +95913,7 @@
             },
         };
     }
-    // version: 1.377.1-db77d3f339
+    // version: 1.378.0-63d7c07562
 
     /*!
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -98029,7 +98029,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$2,
     });
-    // version: 1.377.1-dadb6358f3
+    // version: 1.378.0-0ab3d40d29
 
     const { create: create$3, keys: keys$3 } = Object;
     const { stringify: stringify$1, parse } = JSON;
@@ -98893,11 +98893,7 @@
       if (variable.definition.defaultValue) {
         return extractValue(variable.definition.defaultValue, variableDefinitions);
       }
-      return err$4(
-        new Error(
-          `Variable '${variableName}' was defined but no value was provided and no default value exists`
-        )
-      );
+      return ok$4(void 0);
     }
     function validateExpectedType(value, expectedType) {
       if (!expectedType) {
@@ -99107,6 +99103,243 @@
       }
       return ok$4(false);
     }
+    class BaseScalarFieldDef {
+      constructor(nullable) {
+        this.nullable = nullable;
+      }
+      write(_cache, input) {
+        if (input.data === void 0) {
+          return ok$4({ type: "missing" });
+        }
+        if (input.data === null) {
+          if (!this.nullable) {
+            return err$4([
+              {
+                type: "unknown",
+                error: new Error(
+                  `Got a null value for non-nullable field "${input.selection.name.value}"`
+                )
+              }
+            ]);
+          }
+        }
+        return ok$4({ type: "data", data: input.data });
+      }
+      read(_cache, input) {
+        const normalizedData = input.normalizedData;
+        if (normalizedData.type === "missing") {
+          return ok$4(void 0);
+        }
+        return ok$4(normalizedData.data);
+      }
+      augmentSelections(input) {
+        return input;
+      }
+      buildFieldKey(selection, variables) {
+        return buildFieldKey(selection.name.value, selection.arguments, variables);
+      }
+    }
+    class BaseArrayFieldDef {
+      constructor(items, nullable) {
+        this.items = items;
+        this.nullable = nullable;
+      }
+      augmentSelections(input) {
+        return this.items.augmentSelections(input);
+      }
+      buildFieldKey(selection, variables) {
+        return this.items.buildFieldKey(selection, variables);
+      }
+      write(cache, input) {
+        if (input.data === void 0) {
+          return ok$4({ type: "missing" });
+        }
+        if (input.data === null) {
+          if (!this.nullable) {
+            return err$4([
+              {
+                type: "unknown",
+                error: new Error(
+                  `Got a null value for non-nullable field "${input.selection.name.value}"`
+                )
+              }
+            ]);
+          }
+          return ok$4({ type: "data", data: input.data });
+        }
+        if (!Array.isArray(input.data)) {
+          return err$4([
+            {
+              type: "unknown",
+              error: new Error(
+                `Got a non array value for array field "${input.selection.name.value}"`
+              )
+            }
+          ]);
+        }
+        const arrayNormalizationErrors = [];
+        const normalizedArray = [];
+        input.data.forEach((item, index) => {
+          var _a;
+          const existingItemData = (_a = input.existingNormalizedData) == null ? void 0 : _a[index];
+          const normalizedItemResult = this.items.write(cache, {
+            ...input,
+            data: item,
+            existingNormalizedData: existingItemData,
+            request: input.request,
+            selection: input.selection
+          });
+          if (normalizedItemResult.isOk()) {
+            normalizedArray.push(normalizedItemResult.value);
+          } else {
+            arrayNormalizationErrors.push(...normalizedItemResult.error);
+          }
+        });
+        if (arrayNormalizationErrors.length > 0) {
+          return err$4(arrayNormalizationErrors);
+        }
+        return ok$4({ type: "data", data: normalizedArray });
+      }
+      read(cache, input) {
+        const normalizedData = input.normalizedData;
+        if (normalizedData.type === "missing") {
+          return ok$4(void 0);
+        }
+        if (normalizedData.data === null) {
+          if (!this.nullable) {
+            return err$4([
+              {
+                type: "unknown",
+                error: new Error(
+                  `Got a null value for non-nullable field "${input.selection.name.value}"`
+                )
+              }
+            ]);
+          }
+          return ok$4({ type: "data", data: null });
+        }
+        if (!Array.isArray(normalizedData.data)) {
+          return err$4([
+            {
+              type: "unknown",
+              error: new Error(
+                `Got a non array value for array field "${input.selection.name.value}"`
+              )
+            }
+          ]);
+        }
+        const arrayDenormalizationErrors = [];
+        const denormalizedArray = [];
+        normalizedData.data.forEach((item) => {
+          const denormalizedItemResult = this.items.read(cache, {
+            ...input,
+            normalizedData: item,
+            request: input.request,
+            selection: input.selection
+          });
+          if (denormalizedItemResult.isOk()) {
+            denormalizedArray.push(denormalizedItemResult.value);
+          } else {
+            arrayDenormalizationErrors.push(...denormalizedItemResult.error);
+          }
+        });
+        if (arrayDenormalizationErrors.length > 0) {
+          return err$4(arrayDenormalizationErrors);
+        }
+        return ok$4(denormalizedArray);
+      }
+    }
+    class BaseObjectFieldDef {
+      constructor(repository, nullable) {
+        this.repository = repository;
+        this.nullable = nullable;
+      }
+      augmentSelections(input) {
+        return this.repository.augmentSelections(input);
+      }
+      buildFieldKey(selection, variables) {
+        return this.repository.buildFieldKey(selection, variables);
+      }
+      write(cache, input) {
+        var _a;
+        if (!input.selection.selectionSet) {
+          return err$4([
+            {
+              type: "unknown",
+              error: new Error(
+                `Selection set required for object type found on field "${input.selection.name.value}" in type ${this.repository.typeName}`
+              )
+            }
+          ]);
+        }
+        if (input.data === void 0) {
+          return ok$4({ type: "missing" });
+        }
+        if (input.data === null) {
+          if (!this.nullable) {
+            return err$4([
+              {
+                type: "unknown",
+                error: new Error(
+                  `Got a null value for non-nullable field "${input.selection.name.value}"`
+                )
+              }
+            ]);
+          }
+          return ok$4({ type: "data", data: null });
+        }
+        const writeResult = this.repository.write(cache, {
+          ...input,
+          data: input.data,
+          existingNormalizedData: (_a = input.existingNormalizedData) == null ? void 0 : _a.data,
+          request: input.request,
+          selections: input.selection.selectionSet.selections,
+          parentFieldSelection: input.selection
+        });
+        if (writeResult.isErr()) {
+          return writeResult;
+        }
+        return ok$4({ type: "data", data: writeResult.value });
+      }
+      read(cache, input) {
+        var _a;
+        if (!input.selection.selectionSet) {
+          return err$4([
+            {
+              type: "unknown",
+              error: new Error(
+                `Selection set required for object type found on field "${input.selection.name.value}" in type ${this.repository.typeName}`
+              )
+            }
+          ]);
+        }
+        const normalizedData = input.normalizedData;
+        if (normalizedData.type === "missing") {
+          return ok$4(void 0);
+        }
+        if (normalizedData.data === null) {
+          if (!this.nullable) {
+            return err$4([
+              {
+                type: "unknown",
+                error: new Error(
+                  `Got a null value for non-nullable field "${input.selection.name.value}"`
+                )
+              }
+            ]);
+          }
+          return ok$4(null);
+        }
+        return this.repository.read(cache, {
+          ...input,
+          normalizedData: normalizedData.data,
+          request: input.request,
+          selections: (_a = input.selection.selectionSet) == null ? void 0 : _a.selections,
+          parentFieldSelection: input.selection
+        });
+      }
+    }
+    const missingFieldDef = new BaseScalarFieldDef(false);
     class BaseGraphQLTypeRepository {
       equals(x, y) {
         return deepEquals$2(x, y);
@@ -99471,9 +99704,23 @@
         }
         return {};
       }
-      getFieldDef(_input, selection) {
+      getFieldDef(input, selection) {
+        var _a, _b, _c;
         const canonicalFieldName = selection.name.value;
-        return this.fields[canonicalFieldName];
+        const fieldDef = this.fields[canonicalFieldName];
+        if (fieldDef) {
+          return fieldDef;
+        }
+        const dataInstanceFieldName = ((_a = selection.alias) == null ? void 0 : _a.value) ?? selection.name.value;
+        if (input === void 0) {
+          return void 0;
+        }
+        if ("data" in input && input.data[dataInstanceFieldName] === void 0) {
+          return missingFieldDef;
+        } else if ("normalizedData" in input && ((_c = (_b = input.normalizedData) == null ? void 0 : _b[dataInstanceFieldName]) == null ? void 0 : _c.type) === "missing") {
+          return missingFieldDef;
+        }
+        return void 0;
       }
       shouldProcessFragment(fragment, variables) {
         const shouldSkipResult = shouldSkip(fragment, variables);
@@ -99855,245 +100102,6 @@
       });
       return { selections: augmentedSelections, fragments: augmentedFragments };
     }
-    class BaseScalarFieldDef {
-      constructor(nullable) {
-        this.nullable = nullable;
-        this.type = "scalar";
-      }
-      write(_cache, input) {
-        if (input.data === void 0) {
-          return ok$4({ type: "missing" });
-        }
-        if (input.data === null) {
-          if (!this.nullable) {
-            return err$4([
-              {
-                type: "unknown",
-                error: new Error(
-                  `Got a null value for non-nullable field "${input.selection.name.value}"`
-                )
-              }
-            ]);
-          }
-        }
-        return ok$4({ type: "data", data: input.data });
-      }
-      read(_cache, input) {
-        const normalizedData = input.normalizedData;
-        if (normalizedData.type === "missing") {
-          return ok$4(void 0);
-        }
-        return ok$4(normalizedData.data);
-      }
-      augmentSelections(input) {
-        return input;
-      }
-      buildFieldKey(selection, variables) {
-        return buildFieldKey(selection.name.value, selection.arguments, variables);
-      }
-    }
-    class BaseArrayFieldDef {
-      constructor(items, nullable) {
-        this.items = items;
-        this.nullable = nullable;
-        this.type = "array";
-      }
-      augmentSelections(input) {
-        return this.items.augmentSelections(input);
-      }
-      buildFieldKey(selection, variables) {
-        return this.items.buildFieldKey(selection, variables);
-      }
-      write(cache, input) {
-        if (input.data === void 0) {
-          return ok$4({ type: "missing" });
-        }
-        if (input.data === null) {
-          if (!this.nullable) {
-            return err$4([
-              {
-                type: "unknown",
-                error: new Error(
-                  `Got a null value for non-nullable field "${input.selection.name.value}"`
-                )
-              }
-            ]);
-          }
-          return ok$4({ type: "data", data: input.data });
-        }
-        if (!Array.isArray(input.data)) {
-          return err$4([
-            {
-              type: "unknown",
-              error: new Error(
-                `Got a non array value for array field "${input.selection.name.value}"`
-              )
-            }
-          ]);
-        }
-        const arrayNormalizationErrors = [];
-        const normalizedArray = [];
-        input.data.forEach((item, index) => {
-          var _a;
-          const existingItemData = (_a = input.existingNormalizedData) == null ? void 0 : _a[index];
-          const normalizedItemResult = this.items.write(cache, {
-            ...input,
-            data: item,
-            existingNormalizedData: existingItemData,
-            request: input.request,
-            selection: input.selection
-          });
-          if (normalizedItemResult.isOk()) {
-            normalizedArray.push(normalizedItemResult.value);
-          } else {
-            arrayNormalizationErrors.push(...normalizedItemResult.error);
-          }
-        });
-        if (arrayNormalizationErrors.length > 0) {
-          return err$4(arrayNormalizationErrors);
-        }
-        return ok$4({ type: "data", data: normalizedArray });
-      }
-      read(cache, input) {
-        const normalizedData = input.normalizedData;
-        if (normalizedData.type === "missing") {
-          return ok$4(void 0);
-        }
-        if (normalizedData.data === null) {
-          if (!this.nullable) {
-            return err$4([
-              {
-                type: "unknown",
-                error: new Error(
-                  `Got a null value for non-nullable field "${input.selection.name.value}"`
-                )
-              }
-            ]);
-          }
-          return ok$4({ type: "data", data: null });
-        }
-        if (!Array.isArray(normalizedData.data)) {
-          return err$4([
-            {
-              type: "unknown",
-              error: new Error(
-                `Got a non array value for array field "${input.selection.name.value}"`
-              )
-            }
-          ]);
-        }
-        const arrayDenormalizationErrors = [];
-        const denormalizedArray = [];
-        normalizedData.data.forEach((item) => {
-          const denormalizedItemResult = this.items.read(cache, {
-            ...input,
-            normalizedData: item,
-            request: input.request,
-            selection: input.selection
-          });
-          if (denormalizedItemResult.isOk()) {
-            denormalizedArray.push(denormalizedItemResult.value);
-          } else {
-            arrayDenormalizationErrors.push(...denormalizedItemResult.error);
-          }
-        });
-        if (arrayDenormalizationErrors.length > 0) {
-          return err$4(arrayDenormalizationErrors);
-        }
-        return ok$4(denormalizedArray);
-      }
-    }
-    class BaseObjectFieldDef {
-      constructor(repository, nullable) {
-        this.repository = repository;
-        this.nullable = nullable;
-        this.type = "object";
-      }
-      augmentSelections(input) {
-        return this.repository.augmentSelections(input);
-      }
-      buildFieldKey(selection, variables) {
-        return this.repository.buildFieldKey(selection, variables);
-      }
-      write(cache, input) {
-        var _a;
-        if (!input.selection.selectionSet) {
-          return err$4([
-            {
-              type: "unknown",
-              error: new Error(
-                `Selection set required for object type found on field "${input.selection.name.value}" in type ${this.repository.typeName}`
-              )
-            }
-          ]);
-        }
-        if (input.data === void 0) {
-          return ok$4({ type: "missing" });
-        }
-        if (input.data === null) {
-          if (!this.nullable) {
-            return err$4([
-              {
-                type: "unknown",
-                error: new Error(
-                  `Got a null value for non-nullable field "${input.selection.name.value}"`
-                )
-              }
-            ]);
-          }
-          return ok$4({ type: "data", data: null });
-        }
-        const writeResult = this.repository.write(cache, {
-          ...input,
-          data: input.data,
-          existingNormalizedData: (_a = input.existingNormalizedData) == null ? void 0 : _a.data,
-          request: input.request,
-          selections: input.selection.selectionSet.selections,
-          parentFieldSelection: input.selection
-        });
-        if (writeResult.isErr()) {
-          return writeResult;
-        }
-        return ok$4({ type: "data", data: writeResult.value });
-      }
-      read(cache, input) {
-        var _a;
-        if (!input.selection.selectionSet) {
-          return err$4([
-            {
-              type: "unknown",
-              error: new Error(
-                `Selection set required for object type found on field "${input.selection.name.value}" in type ${this.repository.typeName}`
-              )
-            }
-          ]);
-        }
-        const normalizedData = input.normalizedData;
-        if (normalizedData.type === "missing") {
-          return ok$4(void 0);
-        }
-        if (normalizedData.data === null) {
-          if (!this.nullable) {
-            return err$4([
-              {
-                type: "unknown",
-                error: new Error(
-                  `Got a null value for non-nullable field "${input.selection.name.value}"`
-                )
-              }
-            ]);
-          }
-          return ok$4(null);
-        }
-        return this.repository.read(cache, {
-          ...input,
-          normalizedData: normalizedData.data,
-          request: input.request,
-          selections: (_a = input.selection.selectionSet) == null ? void 0 : _a.selections,
-          parentFieldSelection: input.selection
-        });
-      }
-    }
     const GraphQLQueryJsonSchema = {
       type: "object",
       properties: {
@@ -100394,10 +100402,10 @@
         return;
       }
       if ("subscribe" in result.value) {
-        callback(result.value.data);
+        callback(formatGraphQLData(result.value.data));
         return;
       }
-      callback(result.value);
+      callback(formatGraphQLData(result.value));
     }
     function resolveAst(ast) {
       const result = astResolver(ast);
@@ -100406,6 +100414,18 @@
       }
       return result;
     }
+    function formatGraphQLData(data) {
+      if (data.errors === void 0 || data.errors.length === 0) {
+        return {
+          data: data.data,
+          errors: void 0
+        };
+      }
+      return {
+        data: data.data,
+        errors: data.errors
+      };
+    }
     class GraphQLCommandWireAdapterConstructor extends CommandWireAdapterConstructor {
       emit(result) {
         try {
@@ -100484,7 +100504,7 @@
       };
       return { invoke, subscribe };
     }
-    // version: 1.377.1-db77d3f339
+    // version: 1.378.0-63d7c07562
 
     class Analytics__AnalyticsBrowseRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
@@ -101660,7 +101680,7 @@
         }
     }
 
-    class PolymorphicParentRelationshipRepository extends BaseUnionRepository {
+    let PolymorphicParentRelationshipRepository$1 = class PolymorphicParentRelationshipRepository extends BaseUnionRepository {
         constructor(services, typeRegistry) {
             super(services);
             this.services = services;
@@ -101677,7 +101697,7 @@
                 __typename: new BaseScalarFieldDef(false),
             };
         }
-    }
+    };
 
     class QueryRepository extends GraphQLDocumentRootTypeRepository {
         constructor(services, typeRegistry) {
@@ -102715,7 +102735,7 @@
             this._Base64Value = new Base64ValueRepository(this.services, this);
             this._JSONValue = new JSONValueRepository(this.services, this);
             this._PolymorphicParentRelationship =
-                new PolymorphicParentRelationshipRepository(this.services, this);
+                new PolymorphicParentRelationshipRepository$1(this.services, this);
             this._CompoundField = new CompoundFieldRepository$1(this.services, this);
             this._AnyType = new AnyTypeRepository(this.services, this);
             this._RecordRepresentation =
@@ -103219,8 +103239,6 @@
             return fields[selection.name.value];
         }
         return {
-            type: 'object',
-            nullable: true,
             read: (cache, input) => {
                 if (!input.selection.selectionSet) {
                     return err([
@@ -103234,6 +103252,9 @@
                 if (normalizedData.type === 'missing') {
                     return ok(undefined);
                 }
+                if (normalizedData.data === null) {
+                    return ok(null);
+                }
                 const fieldCategory = normalizedData.fieldCategory;
                 const fieldDef = fields[fieldCategory];
                 if (!fieldDef) {
@@ -103258,6 +103279,9 @@
                 if (input.data === undefined) {
                     return ok({ type: 'missing' });
                 }
+                if (input.data === null) {
+                    return ok({ type: 'data', data: null });
+                }
                 const fieldCategory = getFieldCategoryFromData(input.data);
                 const fieldDef = fields[fieldCategory];
                 if (!fieldDef) {
@@ -103276,7 +103300,6 @@
             },
             buildFieldKey: (selection, variables) => buildFieldKey(selection.name.value, selection.arguments, variables),
             augmentSelections: (input) => input,
-            repository: {}, // This shouldn't be part of the interface
         };
     }
     function getFieldCategoryFromData(data) {
@@ -103328,7 +103351,19 @@
             return this._graphqlRepositoryOverride;
         }
         write(cache, input) {
-            const result = super.write(cache, input);
+            let overridenInput = input;
+            // If ID exists in the data but wasn't asked for, its from the extensions, and we should normalize it
+            if (input.data.Id !== undefined &&
+                input.selections.find((selection) => selection.kind === 'Field' && selection.name.value === 'Id')) {
+                overridenInput = {
+                    ...input,
+                    selections: [
+                        ...input.selections,
+                        { kind: 'Field', name: { kind: 'Name', value: 'Id' } },
+                    ],
+                };
+            }
+            const result = super.write(cache, overridenInput);
             const recordId = input.data.Id;
             const luvioRecord = input.getNormalizedLuvioRecord(recordId, input.reader);
             if (luvioRecord?.weakEtag &&
@@ -103475,8 +103510,6 @@
     }
 
     const blobTypeDef = {
-        type: 'scalar',
-        nullable: true,
         read: (_cache, input) => {
             return ok({
                 data: input.data,
@@ -103586,6 +103619,14 @@
         }
     }
 
+    class PolymorphicParentRelationshipRepository extends PolymorphicParentRelationshipRepository$1 {
+        getTypeDiscriminator(data, _selections) {
+            // Hardcoded to record representation since that's the only type of parent
+            // relationship possible
+            return 'RecordRepresentation';
+        }
+    }
+
     class CustomGraphQLTypeRegistry extends GraphQLTypeRegistry {
         constructor(services) {
             super(services);
@@ -103598,6 +103639,7 @@
             this._SetupQueryAggregate = new SetupQueryAggregateRepository(services, this);
             this._SetupQuery = new SetupQueryRepository(services, this);
             this._SetupRecordAggregate = new SetupRecordAggregateRepository(services, this);
+            this._PolymorphicParentRelationship = new PolymorphicParentRelationshipRepository(services, this);
         }
         get CompoundField() {
             return this._CompoundField;
@@ -103626,155 +103668,75 @@
         get SetupRecordAggregate() {
             return this._SetupRecordAggregate;
         }
+        get PolymorphicParentRelationship() {
+            return this._PolymorphicParentRelationship;
+        }
     }
 
     const CONFIG_SCHEMA = GraphQLQueryJsonSchema;
 
-    // Fields with arguments need to be aliased to avoid a potential conflict.
-    const ALIASED_FIELDS = {
-        ldsRecordTypeId: {
-            kind: Kind$1.FIELD,
-            name: {
-                kind: Kind$1.NAME,
-                value: 'RecordTypeId',
-            },
-            arguments: [
-                {
-                    kind: Kind$1.ARGUMENT,
-                    name: {
-                        kind: Kind$1.NAME,
-                        value: 'fallback',
-                    },
-                    value: {
-                        kind: Kind$1.BOOLEAN,
-                        value: true,
-                    },
-                },
-            ],
-            alias: {
-                kind: Kind$1.NAME,
-                value: 'ldsRecordTypeId',
-            },
-        },
-    };
-    // TODO: export graphql's deepMerge from @luvio/graphql-normalization? Promote to @luvio/utils?
-    function deepMerge$1(target, source) {
-        if (source === null || source === undefined)
-            return target;
-        if (target === null || target === undefined)
-            return source;
-        if (typeof source !== 'object' || typeof target !== 'object') {
-            return source;
-        }
-        if (Array.isArray(source)) {
-            return source;
-        }
-        const result = { ...target };
-        for (const key of Object.keys(source)) {
-            if (key === 'extensions') {
-                // Skip extensions key from final result
-                continue;
-            }
-            if (source[key] !== null &&
-                typeof source[key] === 'object' &&
-                !Array.isArray(source[key])) {
-                result[key] = deepMerge$1(result[key], source[key]);
-            }
-            else {
-                result[key] = source[key];
-            }
-        }
-        return result;
-    }
-    function createFieldNode(name, data) {
-        if (name === '__genericTypename') {
-            return undefined;
-        }
-        const baseField = ALIASED_FIELDS[name] ?? {
-            kind: Kind$1.FIELD,
-            name: {
-                kind: Kind$1.NAME,
-                value: name,
-            },
-        };
-        if (typeof data === 'object' && data !== null && data !== undefined) {
-            if (Array.isArray(data)) {
-                // For arrays, we need to merge the structure from all non-null elements
-                // to capture the full schema, not just the first element
-                let mergedStructure = {};
-                for (const item of data) {
-                    if (item !== null && typeof item === 'object' && !Array.isArray(item)) {
-                        mergedStructure = deepMerge$1(mergedStructure, item);
-                    }
-                }
-                if (Object.keys(mergedStructure).length > 0) {
-                    baseField.selectionSet = {
-                        kind: Kind$1.SELECTION_SET,
-                        selections: Object.entries(mergedStructure)
-                            .map(([key, value]) => createFieldNode(key, value))
-                            .filter((node) => node !== undefined),
-                    };
-                }
-            }
-            else {
-                baseField.selectionSet = {
-                    kind: Kind$1.SELECTION_SET,
-                    selections: Object.entries(data)
-                        .map(([key, value]) => createFieldNode(key, value))
-                        .filter((node) => node !== undefined),
-                };
-            }
-        }
-        return baseField;
-    }
-    function createASTFromExtensions(extensions) {
-        const fieldNodes = Object.entries(extensions)
-            .map(([field, value]) => createFieldNode(field, value))
-            .filter((node) => node !== undefined);
-        return {
-            kind: Kind$1.SELECTION_SET,
-            selections: fieldNodes,
-        };
-    }
-    function mergeASTs(query, extensionsAST) {
-        return {
-            ...query,
-            definitions: query.definitions.map((def) => {
-                if (def.kind === Kind$1.OPERATION_DEFINITION) {
-                    return {
-                        ...def,
-                        selectionSet: {
-                            kind: Kind$1.SELECTION_SET,
-                            selections: [...def.selectionSet.selections, ...extensionsAST.selections],
-                        },
-                    };
-                }
-                return def;
-            }),
-        };
-    }
-    /**
-     * Augments a query with the extensions from a response. The general algorithm is:
-     * 1. Create an AST from just the extensions.
-     * 2. Deep merge the extensions AST into the query AST.
-     * 3. Deep merge the extensions into the response data.
-     * 4. Return the augmented query and response.
-     * @param query - The query to augment.
-     * @param response - The response to augment the query with.
-     * @returns The augmented query and response.
-     */
-    function augmentQueryByResponse(query, response) {
-        const extensions = response.extensions?.lds || {};
-        const extensionsAST = createASTFromExtensions(extensions);
-        const augmentedQuery = mergeASTs(query, extensionsAST);
-        // Deep merge extensions into data, removing extensions key from result
-        const mergedData = deepMerge$1(response.data, extensions);
-        return {
-            query: augmentedQuery,
-            response: {
-                data: mergedData,
-                ...(response.errors && { errors: response.errors }),
-            },
+    function mergeResponseWithExtensions(response) {
+        return {
+            data: deepMerge$1(response.data, response.extensions?.lds || {}),
+            ...(response.errors && { errors: response.errors }),
+        };
+    }
+    function deepMerge$1(data, extensions) {
+        const dataType = typeof data;
+        const extensionsType = typeof extensions;
+        if (dataType === 'function' || extensionsType === 'function') {
+            throw new Error('Cannot merge functions');
+        }
+        if (dataType === 'undefined' || data === undefined) {
+            return extensions;
+        }
+        if (extensionsType === 'undefined' || extensions === undefined) {
+            return data;
+        }
+        if (dataType === 'string' ||
+            dataType === 'number' ||
+            dataType === 'boolean' ||
+            dataType === 'bigint' ||
+            dataType === 'symbol' ||
+            extensionsType === 'string' ||
+            extensionsType === 'number' ||
+            extensionsType === 'boolean' ||
+            extensionsType === 'bigint' ||
+            extensionsType === 'symbol' ||
+            data === null ||
+            extensions === null) {
+            // if either is a scalar, prefer data
+            return data;
+        }
+        // data and extensions are both objects or arrays
+        // if data is an array but extensions is not, prefer data
+        const dataIsArray = Array.isArray(data);
+        const extensionsIsArray = Array.isArray(extensions);
+        // if one is an array and the other is not, prefer data
+        if ((dataIsArray && !extensionsIsArray) || (!dataIsArray && extensionsIsArray)) {
+            return data;
+        }
+        // if both are arrays, merge them, maintaining the length of data
+        if (dataIsArray && extensionsIsArray) {
+            return data.map((item, index) => deepMerge$1(item, extensions[index]));
+        }
+        // if both are objects, merge them
+        // get the keys of both objects
+        const dataKeys = Object.keys(data);
+        const extensionsKeys = Object.keys(extensions);
+        // get the keys that are in both objects
+        const commonKeys = dataKeys.filter((key) => extensionsKeys.includes(key));
+        // get the keys that are in data but not in extensions
+        const dataKeysNotInExtensions = dataKeys.filter((key) => !extensionsKeys.includes(key));
+        // get the keys that are in extensions but not in data
+        const extensionsKeysNotInData = extensionsKeys.filter((key) => !dataKeys.includes(key));
+        return {
+            ...Object.fromEntries(commonKeys.map((key) => [
+                key,
+                deepMerge$1(data[key], extensions[key]),
+            ])),
+            ...Object.fromEntries(dataKeysNotInExtensions.map((key) => [key, data[key]])),
+            ...Object.fromEntries(extensionsKeysNotInData.map((key) => [key, extensions[key]])),
         };
     }
 
@@ -103832,17 +103794,16 @@
             }
             buildWriteInput(data) {
                 this.latestLuvioRecordIdsToInvalidate = [];
-                const baseQuery = this.buildRequestQuery();
-                const { query: augmentedQuery, response: augmentedData } = augmentQueryByResponse(baseQuery, data);
+                const augmentedResponse = mergeResponseWithExtensions(data);
                 const extensionResult = buildGraphQLInputExtension({
                     ...this.config,
-                    query: augmentedQuery,
+                    query: this.buildRequestQuery(),
                 });
                 if (extensionResult.isErr()) {
                     throw new InternalError(extensionResult.error);
                 }
                 return {
-                    data: augmentedData.data,
+                    data: augmentedResponse.data,
                     ...extensionResult.value,
                     luvioRecordIdsToInvalidate: this.latestLuvioRecordIdsToInvalidate,
                 };
@@ -103898,7 +103859,7 @@
                             synthetic: true,
                             read: (reader) => {
                                 if (networkResult.isOk()) {
-                                    const x = this.buildResultType().write(cache.buildFixedTimeWritableCache(Date.now() / 1000), {
+                                    return this.buildResultType().write(cache.buildFixedTimeWritableCache(Date.now() / 1000), {
                                         ...this.buildWriteInput(networkResult.value),
                                         reader,
                                         getNormalizedLuvioRecord: this.services.luvioUiapiRecords
@@ -103912,7 +103873,6 @@
                 }
                 catch (error) {
                     // swallow error
-                    console.error(error);
                 }
                 return resolvedPromiseLike(undefined);
             }
@@ -104030,7 +103990,7 @@
             cb(graphql$1, graphql_imperative$1, useOneStoreGraphQL);
         }
     }
-    // version: 1.377.1-db77d3f339
+    // version: 1.378.0-63d7c07562
 
     function createFragmentMap(documentNode) {
         const fragments = {};
@@ -130525,7 +130485,7 @@
         }
         return refresh$3(data, 'refreshUiApi');
     }
-    // version: 1.377.1-db77d3f339
+    // version: 1.378.0-63d7c07562
 
     // On core the unstable adapters are re-exported with different names,
     // we want to match them here.
@@ -130677,7 +130637,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.377.1-db77d3f339
+    // version: 1.378.0-63d7c07562
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -131476,7 +131436,7 @@
     function register(r) {
         callbacks$1.forEach((callback) => callback(r));
     }
-    // version: 1.377.1-dadb6358f3
+    // version: 1.378.0-0ab3d40d29
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -132813,4 +132773,4 @@
     exports.subscribeToAdapter = subscribeToAdapter;
 
 }));
-// version: 1.377.1-dadb6358f3
+// version: 1.378.0-0ab3d40d29