@salesforce/lds-worker-api 1.377.1 → 1.378.0

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

@@ -4274,7 +4274,7 @@ function withDefaultLuvio(callback) {
     }
     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) {
@@ -5318,7 +5318,7 @@ function createGraphQLWireAdapterConstructor(luvio, adapter, metadata, astResolv
     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.,
@@ -34154,7 +34154,7 @@ withDefaultLuvio((luvio) => {
     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) {
@@ -87029,9 +87029,9 @@ function injectFilter(filterNode, idState, parentPath, isParentPolymorphic, obje
                         }
                         // 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]];
@@ -87077,7 +87077,7 @@ function injectFilter(filterNode, idState, parentPath, isParentPolymorphic, obje
                                 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 ||
@@ -87144,7 +87144,7 @@ function injectFilter(filterNode, idState, parentPath, isParentPolymorphic, obje
                                     .filter(isFieldNode)
                                     .filter((subNode) => subNode.name.value === relationField);
                             if (!existingRelationFields || existingRelationFields.length === 0) {
-                                injectedSelections.push(createFieldNode$1(relationField, FieldValueNodeSelectionSet));
+                                injectedSelections.push(createFieldNode(relationField, FieldValueNodeSelectionSet));
                             }
                         }
                     }
@@ -87235,7 +87235,7 @@ function produceValueFieldLeaves(queryNode) {
             .filter(isFieldNode)
             .filter((subNode) => subNode.name.value === 'value');
     return !existingValueFields || existingValueFields.length === 0
-        ? [createFieldNode$1('value')]
+        ? [createFieldNode('value')]
         : [];
 }
 function updateIDInfo(fieldNode, idState, draftFunctions) {
@@ -87316,20 +87316,20 @@ function injectParentRelationships(selections, parentNode, parentPath, ancestors
                     .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) {
@@ -87373,7 +87373,7 @@ function injectFieldsForDisplayValue(topNode, apiName, objectInfos) {
             objectInfo.nameFields !== undefined &&
             objectInfo.nameFields.length > 0) {
             displayValueNameFields = objectInfo.nameFields.map((fieldName) => {
-                return createFieldNode$1(fieldName, FieldValueNodeSelectionSet);
+                return createFieldNode(fieldName, FieldValueNodeSelectionSet);
             });
         }
     }
@@ -87404,7 +87404,7 @@ function injectFields(selections, parentNode, parentPath, ancestors, objectInfos
         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
@@ -87432,7 +87432,7 @@ function injectFields(selections, parentNode, parentPath, ancestors, objectInfos
                             .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));
                     }
@@ -87884,7 +87884,7 @@ function referenceIdFieldForRelationship(relationshipName) {
  * @param selectionSet
  * @returns
  */
-function createFieldNode$1(nameValue, selectionSet) {
+function createFieldNode(nameValue, selectionSet) {
     return {
         kind: Kind$3.FIELD,
         name: {
@@ -95881,7 +95881,7 @@ function buildServiceDescriptor$5(luvio) {
         },
     };
 }
-// version: 1.377.1-db77d3f339
+// version: 1.378.0-63d7c07562
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -95907,7 +95907,7 @@ function buildServiceDescriptor$4(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.377.1-db77d3f339
+// version: 1.378.0-63d7c07562
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -98023,7 +98023,7 @@ register$1({
     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;
@@ -98887,11 +98887,7 @@ function extractVariableValue(variableName, variableDefinitions) {
   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) {
@@ -99101,6 +99097,243 @@ function shouldSkip(selection, variables) {
   }
   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);
@@ -99465,9 +99698,23 @@ class BaseGraphQLTypeRepository {
     }
     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);
@@ -99849,245 +100096,6 @@ function augmentUnionLikeSelections(input, possibleTypes) {
   });
   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: {
@@ -100388,10 +100396,10 @@ function emitGraphQLResult(callback, result) {
     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);
@@ -100400,6 +100408,18 @@ function resolveAst(ast) {
   }
   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 {
@@ -100478,7 +100498,7 @@ function buildAsyncGraphQLImperativeLegacyInvoker(getCommand) {
   };
   return { invoke, subscribe };
 }
-// version: 1.377.1-db77d3f339
+// version: 1.378.0-63d7c07562
 
 class Analytics__AnalyticsBrowseRepository extends UnidentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
@@ -101654,7 +101674,7 @@ class PolymorphicAggregateParentRelationshipRepository extends BaseUnionReposito
     }
 }
 
-class PolymorphicParentRelationshipRepository extends BaseUnionRepository {
+let PolymorphicParentRelationshipRepository$1 = class PolymorphicParentRelationshipRepository extends BaseUnionRepository {
     constructor(services, typeRegistry) {
         super(services);
         this.services = services;
@@ -101671,7 +101691,7 @@ class PolymorphicParentRelationshipRepository extends BaseUnionRepository {
             __typename: new BaseScalarFieldDef(false),
         };
     }
-}
+};
 
 class QueryRepository extends GraphQLDocumentRootTypeRepository {
     constructor(services, typeRegistry) {
@@ -102709,7 +102729,7 @@ class GraphQLTypeRegistry {
         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 =
@@ -103213,8 +103233,6 @@ function buildGenericTypeFieldDef(selection, fields, staticFieldNames, typename)
         return fields[selection.name.value];
     }
     return {
-        type: 'object',
-        nullable: true,
         read: (cache, input) => {
             if (!input.selection.selectionSet) {
                 return err([
@@ -103228,6 +103246,9 @@ function buildGenericTypeFieldDef(selection, fields, staticFieldNames, typename)
             if (normalizedData.type === 'missing') {
                 return ok(undefined);
             }
+            if (normalizedData.data === null) {
+                return ok(null);
+            }
             const fieldCategory = normalizedData.fieldCategory;
             const fieldDef = fields[fieldCategory];
             if (!fieldDef) {
@@ -103252,6 +103273,9 @@ function buildGenericTypeFieldDef(selection, fields, staticFieldNames, typename)
             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) {
@@ -103270,7 +103294,6 @@ function buildGenericTypeFieldDef(selection, fields, staticFieldNames, typename)
         },
         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) {
@@ -103322,7 +103345,19 @@ class RecordRepresentationRepository extends RecordRepresentationRepository$1 {
         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 &&
@@ -103469,8 +103504,6 @@ class RecordQueryAggregateRepository extends RecordQueryAggregateRepository$1 {
 }
 
 const blobTypeDef = {
-    type: 'scalar',
-    nullable: true,
     read: (_cache, input) => {
         return ok({
             data: input.data,
@@ -103580,6 +103613,14 @@ class SetupRecordAggregateRepository extends Setup__SetupRecordAggregateReposito
     }
 }
 
+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);
@@ -103592,6 +103633,7 @@ class CustomGraphQLTypeRegistry extends GraphQLTypeRegistry {
         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;
@@ -103620,155 +103662,75 @@ class CustomGraphQLTypeRegistry extends GraphQLTypeRegistry {
     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]])),
     };
 }
 
@@ -103826,17 +103788,16 @@ function buildCommandClass(baseClass) {
         }
         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,
             };
@@ -103892,7 +103853,7 @@ function buildCommandClass(baseClass) {
                         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
@@ -103906,7 +103867,6 @@ function buildCommandClass(baseClass) {
             }
             catch (error) {
                 // swallow error
-                console.error(error);
             }
             return resolvedPromiseLike(undefined);
         }
@@ -104024,7 +103984,7 @@ function registerCallback(cb) {
         cb(graphql$1, graphql_imperative$1, useOneStoreGraphQL);
     }
 }
-// version: 1.377.1-db77d3f339
+// version: 1.378.0-63d7c07562
 
 function createFragmentMap(documentNode) {
     const fragments = {};
@@ -130519,7 +130479,7 @@ function refreshGraphQL(data) {
     }
     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.
@@ -130671,7 +130631,7 @@ withDefaultLuvio((luvio) => {
     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,
@@ -131470,7 +131430,7 @@ const callbacks$1 = [];
 function register(r) {
     callbacks$1.forEach((callback) => callback(r));
 }
-// version: 1.377.1-dadb6358f3
+// version: 1.378.0-0ab3d40d29
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -132786,4 +132746,4 @@ const { luvio } = getRuntime();
 setDefaultLuvio({ luvio });
 
 export { createPrimingSession, draftManager, draftQueue, evictCacheRecordsByIds, evictExpiredCacheEntries, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, importLuvioAdapterModule, importOneStoreAdapterModule, invokeAdapter, invokeAdapterWithDraftToMerge, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, registerReportObserver, setMetadataTTL, setUiApiRecordTTL, stopEviction, subscribeToAdapter };
-// version: 1.377.1-dadb6358f3
+// version: 1.378.0-0ab3d40d29