@salesforce/lds-worker-api 1.378.0 → 1.379.0

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

@@ -4280,7 +4280,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.378.0-0ab3d40d29
+    // version: 1.379.0-fc97fd9203
 
     // 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.378.0-0ab3d40d29
+    // version: 1.379.0-fc97fd9203
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -34160,7 +34160,7 @@
         throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
         throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
     });
-    // version: 1.378.0-63d7c07562
+    // version: 1.379.0-a57c798add
 
     function requestIdleDetectedCallback(_callback) { }
     function declareNotifierTaskSingle(_name) {
@@ -45770,15 +45770,6 @@
         },
     };
 
-    var productConsumedSideEffects = {
-        isOpen: function (e) {
-            return e.fallback;
-        },
-        hasError: function () {
-            return !0;
-        },
-    };
-
     var useOneStore = {
         isOpen: function (e) {
             return e.fallback;
@@ -46123,6 +46114,15 @@
       return ok$4(data);
     }
 
+    var productConsumedSideEffects = {
+        isOpen: function (e) {
+            return e.fallback;
+        },
+        hasError: function () {
+            return !0;
+        },
+    };
+
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
      * All rights reserved.
@@ -95887,7 +95887,7 @@
             },
         };
     }
-    // version: 1.378.0-63d7c07562
+    // version: 1.379.0-a57c798add
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -95913,7 +95913,7 @@
             },
         };
     }
-    // version: 1.378.0-63d7c07562
+    // version: 1.379.0-a57c798add
 
     /*!
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -98029,7 +98029,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$2,
     });
-    // version: 1.378.0-0ab3d40d29
+    // version: 1.379.0-fc97fd9203
 
     const { create: create$3, keys: keys$3 } = Object;
     const { stringify: stringify$1, parse } = JSON;
@@ -99408,7 +99408,11 @@
       }
       augmentInlineFragmentSelection(fragment, fragments) {
         var _a;
-        if (!this.satisfiesFragmentTypeCondition(fragment)) {
+        const satisfiedFragmentTypeConditionResult = this.satisfiesFragmentTypeCondition(
+          void 0,
+          fragment
+        );
+        if (satisfiedFragmentTypeConditionResult.isErr() || !satisfiedFragmentTypeConditionResult.value) {
           return { selections: [], fragments };
         }
         const augmentedFragmentSelections = this.augmentSelections({
@@ -99434,7 +99438,11 @@
         if (fragment === void 0) {
           return { selections: [selection], fragments };
         }
-        if (!this.satisfiesFragmentTypeCondition(fragment)) {
+        const satisfiedFragmentTypeConditionResult = this.satisfiesFragmentTypeCondition(
+          void 0,
+          fragment
+        );
+        if (satisfiedFragmentTypeConditionResult.isErr() || !satisfiedFragmentTypeConditionResult.value) {
           return { selections: [], fragments };
         }
         const augmentedFragmentSelections = this.augmentSelections({
@@ -99547,10 +99555,7 @@
         };
       }
       normalizeFragment(cache, input, fragment, errorCollector) {
-        const shouldProcessResult = this.shouldProcessFragment(
-          fragment,
-          input.request.definitions.variables
-        );
+        const shouldProcessResult = this.shouldProcessFragment(input, fragment);
         if (shouldProcessResult.isErr()) {
           errorCollector.push({
             type: "unknown",
@@ -99681,10 +99686,7 @@
         };
       }
       denormalizeFragment(cache, input, fragment, errorCollector) {
-        const shouldProcessResult = this.shouldProcessFragment(
-          fragment,
-          input.request.definitions.variables
-        );
+        const shouldProcessResult = this.shouldProcessFragment(input, fragment);
         if (shouldProcessResult.isErr()) {
           errorCollector.push({
             type: "unknown",
@@ -99722,28 +99724,28 @@
         }
         return void 0;
       }
-      shouldProcessFragment(fragment, variables) {
-        const shouldSkipResult = shouldSkip(fragment, variables);
+      shouldProcessFragment(input, fragment) {
+        const shouldSkipResult = shouldSkip(fragment, input.request.definitions.variables);
         if (shouldSkipResult.isErr()) {
           return shouldSkipResult;
         }
         if (shouldSkipResult.value) {
           return ok$4(false);
         }
-        return ok$4(this.satisfiesFragmentTypeCondition(fragment));
+        return this.satisfiesFragmentTypeCondition(input, fragment);
       }
-      satisfiesFragmentTypeCondition(fragment) {
+      satisfiesFragmentTypeCondition(_input, fragment) {
         if (!fragment.typeCondition) {
-          return true;
+          return ok$4(true);
         }
         const conditionalTypeName = fragment.typeCondition.name.value;
         if (conditionalTypeName === this.typeName) {
-          return true;
+          return ok$4(true);
         }
         if (this.implementedInterfaces.includes(conditionalTypeName)) {
-          return true;
+          return ok$4(true);
         }
-        return false;
+        return ok$4(false);
       }
       getCacheKeyFieldArguments(selection) {
         return selection.arguments;
@@ -100472,10 +100474,11 @@
       }
     }
     function buildAsyncGraphQLImperativeLegacyInvoker(getCommand) {
-      const invoke = async (config, _requestContext, callback) => {
+      const invoke = async (config, requestContext, callback) => {
         const command = getCommand({ config, assertIsValid });
         try {
-          const result = await command.execute();
+          const overrides = requestContextIsCachePolicy(requestContext) ? { cacheControlConfig: { type: "no-cache" } } : {};
+          const result = await command.execute(overrides);
           if (result.isOk()) {
             deepFreeze(result.value);
           }
@@ -100484,11 +100487,12 @@
           emitGraphQLResult(callback, err$1(error));
         }
       };
-      const subscribe = (config, _requestContext, callback) => {
+      const subscribe = (config, requestContext, callback) => {
         const command = getCommand({ config, assertIsValid });
         let unsubscribe = () => {
         };
-        command.execute().then((result) => {
+        const overrides = requestContextIsCachePolicy(requestContext) ? { cacheControlConfig: { type: "no-cache" } } : {};
+        command.execute(overrides).then((result) => {
           if (!result.isOk()) {
             emitGraphQLResult(callback, result);
             return;
@@ -100504,7 +100508,10 @@
       };
       return { invoke, subscribe };
     }
-    // version: 1.378.0-63d7c07562
+    function requestContextIsCachePolicy(requestContext) {
+      return typeof requestContext === "object" && requestContext !== null && "cachePolicy" in requestContext && typeof requestContext.cachePolicy === "object" && requestContext.cachePolicy !== null && "type" in requestContext.cachePolicy && requestContext.cachePolicy.type === "no-cache";
+    }
+    // version: 1.379.0-a57c798add
 
     class Analytics__AnalyticsBrowseRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
@@ -100716,7 +100723,14 @@
             this.namespace = "oas";
             this.typeName = "AnyType";
             this.implementedInterfaces = [];
-            this.possibleTypes = {
+        }
+        get fields() {
+            return {
+                __typename: new BaseScalarFieldDef(false),
+            };
+        }
+        get possibleTypes() {
+            return {
                 BooleanValue: this.typeRegistry.BooleanValue,
                 DateValue: this.typeRegistry.DateValue,
                 DateTimeValue: this.typeRegistry.DateTimeValue,
@@ -100724,11 +100738,6 @@
                 StringValue: this.typeRegistry.StringValue,
             };
         }
-        get fields() {
-            return {
-                __typename: new BaseScalarFieldDef(false),
-            };
-        }
     }
 
     class Base64ValueRepository extends UnidentifiableGraphQLTypeRepository {
@@ -101661,7 +101670,7 @@
         }
     }
 
-    class PolymorphicAggregateParentRelationshipRepository extends BaseUnionRepository {
+    let PolymorphicAggregateParentRelationshipRepository$1 = class PolymorphicAggregateParentRelationshipRepository extends BaseUnionRepository {
         constructor(services, typeRegistry) {
             super(services);
             this.services = services;
@@ -101669,16 +101678,18 @@
             this.namespace = "oas";
             this.typeName = "PolymorphicAggregateParentRelationship";
             this.implementedInterfaces = [];
-            this.possibleTypes = {
-                RecordAggregate: this.typeRegistry.RecordAggregate,
-            };
         }
         get fields() {
             return {
                 __typename: new BaseScalarFieldDef(false),
             };
         }
-    }
+        get possibleTypes() {
+            return {
+                RecordAggregate: this.typeRegistry.RecordAggregate,
+            };
+        }
+    };
 
     let PolymorphicParentRelationshipRepository$1 = class PolymorphicParentRelationshipRepository extends BaseUnionRepository {
         constructor(services, typeRegistry) {
@@ -101688,15 +101699,17 @@
             this.namespace = "oas";
             this.typeName = "PolymorphicParentRelationship";
             this.implementedInterfaces = [];
-            this.possibleTypes = {
-                RecordRepresentation: this.typeRegistry.RecordRepresentation,
-            };
         }
         get fields() {
             return {
                 __typename: new BaseScalarFieldDef(false),
             };
         }
+        get possibleTypes() {
+            return {
+                RecordRepresentation: this.typeRegistry.RecordRepresentation,
+            };
+        }
     };
 
     class QueryRepository extends GraphQLDocumentRootTypeRepository {
@@ -101721,7 +101734,7 @@
         }
     }
 
-    class RecordAggregateConnectionRepository extends UnidentifiableGraphQLTypeRepository {
+    let RecordAggregateConnectionRepository$1 = class RecordAggregateConnectionRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
             super(services);
             this.services = services;
@@ -101738,9 +101751,9 @@
                 totalCount: new BaseScalarFieldDef(false),
             };
         }
-    }
+    };
 
-    class RecordAggregateEdgeRepository extends UnidentifiableGraphQLTypeRepository {
+    let RecordAggregateEdgeRepository$1 = class RecordAggregateEdgeRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
             super(services);
             this.services = services;
@@ -101756,7 +101769,7 @@
                 cursor: new BaseScalarFieldDef(false),
             };
         }
-    }
+    };
 
     let RecordAggregateRepository$1 = class RecordAggregateRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
@@ -101794,7 +101807,7 @@
         }
     };
 
-    class RecordConnectionRepository extends UnidentifiableGraphQLTypeRepository {
+    let RecordConnectionRepository$1 = class RecordConnectionRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
             super(services);
             this.services = services;
@@ -101812,9 +101825,9 @@
                 pageResultCount: new BaseScalarFieldDef(false),
             };
         }
-    }
+    };
 
-    class RecordEdgeRepository extends UnidentifiableGraphQLTypeRepository {
+    let RecordEdgeRepository$1 = class RecordEdgeRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
             super(services);
             this.services = services;
@@ -101830,7 +101843,7 @@
                 cursor: new BaseScalarFieldDef(false),
             };
         }
-    }
+    };
 
     let RecordQueryAggregateRepository$1 = class RecordQueryAggregateRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
@@ -101925,7 +101938,7 @@
         }
     };
 
-    class RecordResultRepository extends UnidentifiableGraphQLTypeRepository {
+    let RecordResultRepository$1 = class RecordResultRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
             super(services);
             this.services = services;
@@ -101940,7 +101953,7 @@
                 aggregate: new BaseObjectFieldDef(this.typeRegistry.RecordAggregate, true),
             };
         }
-    }
+    };
 
     class RecordTypeInfoRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
@@ -102363,15 +102376,17 @@
             this.namespace = "oas";
             this.typeName = "Setup__SetupPolymorphicAggregateParentRelationship";
             this.implementedInterfaces = [];
-            this.possibleTypes = {
-                Setup__SetupRecordAggregate: this.typeRegistry.Setup__SetupRecordAggregate,
-            };
         }
         get fields() {
             return {
                 __typename: new BaseScalarFieldDef(false),
             };
         }
+        get possibleTypes() {
+            return {
+                Setup__SetupRecordAggregate: this.typeRegistry.Setup__SetupRecordAggregate,
+            };
+        }
     }
 
     class Setup__SetupPolymorphicParentRelationshipRepository extends BaseUnionRepository {
@@ -102382,15 +102397,17 @@
             this.namespace = "oas";
             this.typeName = "Setup__SetupPolymorphicParentRelationship";
             this.implementedInterfaces = [];
-            this.possibleTypes = {
-                Setup__EntityRepresentation: this.typeRegistry.Setup__EntityRepresentation,
-            };
         }
         get fields() {
             return {
                 __typename: new BaseScalarFieldDef(false),
             };
         }
+        get possibleTypes() {
+            return {
+                Setup__EntityRepresentation: this.typeRegistry.Setup__EntityRepresentation,
+            };
+        }
     }
 
     class Setup__SetupQueryAggregateRepository extends UnidentifiableGraphQLTypeRepository {
@@ -102740,10 +102757,10 @@
             this._AnyType = new AnyTypeRepository(this.services, this);
             this._RecordRepresentation =
                 new RecordRepresentationRepository$1(this.services, this);
-            this._RecordEdge = new RecordEdgeRepository(this.services, this);
+            this._RecordEdge = new RecordEdgeRepository$1(this.services, this);
             this._PageInfo = new PageInfoRepository(this.services, this);
             this._RecordConnection =
-                new RecordConnectionRepository(this.services, this);
+                new RecordConnectionRepository$1(this.services, this);
             this._RecordQuery = new RecordQueryRepository$1(this.services, this);
             this._BooleanAggregate =
                 new BooleanAggregateRepository(this.services, this);
@@ -102773,13 +102790,13 @@
             this._TimeAggregate = new TimeAggregateRepository(this.services, this);
             this._UrlAggregate = new UrlAggregateRepository(this.services, this);
             this._PolymorphicAggregateParentRelationship =
-                new PolymorphicAggregateParentRelationshipRepository(this.services, this);
+                new PolymorphicAggregateParentRelationshipRepository$1(this.services, this);
             this._RecordAggregate = new RecordAggregateRepository$1(this.services, this);
-            this._RecordResult = new RecordResultRepository(this.services, this);
+            this._RecordResult = new RecordResultRepository$1(this.services, this);
             this._RecordAggregateEdge =
-                new RecordAggregateEdgeRepository(this.services, this);
+                new RecordAggregateEdgeRepository$1(this.services, this);
             this._RecordAggregateConnection =
-                new RecordAggregateConnectionRepository(this.services, this);
+                new RecordAggregateConnectionRepository$1(this.services, this);
             this._RecordQueryAggregate =
                 new RecordQueryAggregateRepository$1(this.services, this);
             this._ChildRelationship =
@@ -103329,9 +103346,19 @@
                 'RecordTypeId',
             ];
         }
-        getFieldDef(input, selection) {
+        getFieldDef(_input, selection) {
             return buildGenericTypeFieldDef(selection, this.fields, this.staticFieldNames, this.typeName);
         }
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
     }
 
     class RecordRepresentationRepository extends RecordRepresentationRepository$1 {
@@ -103354,15 +103381,26 @@
             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')) {
+                !input.selections.find((selection) => selection.kind === 'Field' && selection.name.value === 'Id')) {
                 overridenInput = {
-                    ...input,
+                    ...overridenInput,
                     selections: [
-                        ...input.selections,
+                        ...overridenInput.selections,
                         { kind: 'Field', name: { kind: 'Name', value: 'Id' } },
                     ],
                 };
             }
+            // If WeakEtag exists in the data but wasn't asked for, its from the extensions, and we should normalize it
+            if (input.data.WeakEtag !== undefined &&
+                !input.selections.find((selection) => selection.kind === 'Field' && selection.name.value === 'WeakEtag')) {
+                overridenInput = {
+                    ...overridenInput,
+                    selections: [
+                        ...overridenInput.selections,
+                        { kind: 'Field', name: { kind: 'Name', value: 'WeakEtag' } },
+                    ],
+                };
+            }
             const result = super.write(cache, overridenInput);
             const recordId = input.data.Id;
             const luvioRecord = input.getNormalizedLuvioRecord(recordId, input.reader);
@@ -103375,13 +103413,18 @@
         }
         read(cache, input) {
             const result = super.read(cache, input);
-            const idData = super.read(cache, {
+            const trackingData = super.read(cache, {
                 ...input,
-                selections: [{ kind: 'Field', name: { kind: 'Name', value: 'Id' } }],
+                selections: [
+                    { kind: 'Field', name: { kind: 'Name', value: 'Id' } },
+                    { kind: 'Field', name: { kind: 'Name', value: 'WeakEtag' } },
+                ],
             });
-            if (idData.isOk()) {
+            if (trackingData.isOk()) {
                 // Read the record to track subscription
-                input.getNormalizedLuvioRecord(idData.value.Id, input.reader);
+                input.getNormalizedLuvioRecord(trackingData.value.Id, input.reader);
+                // Track the weak etag for the record for cross cache invalidation
+                input.usedRecordIdToWeakEtagMap[trackingData.value.Id] = trackingData.value.WeakEtag;
             }
             return result;
         }
@@ -103474,6 +103517,16 @@
         isBaseFieldSelection(selection) {
             return super.getFieldDef(undefined, selection) !== undefined;
         }
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
     }
 
     class RecordQueryRepository extends RecordQueryRepository$1 {
@@ -103495,6 +103548,16 @@
         getFieldDef(input, selection) {
             return buildGenericTypeFieldDef(selection, this.fields, this.staticFieldNames, this.typeName);
         }
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
     }
 
     class RecordQueryAggregateRepository extends RecordQueryAggregateRepository$1 {
@@ -103509,10 +103572,12 @@
         }
     }
 
+    // This should be smarter, and filter on selections, but for now,
+    // we'll match the luvio behavior of returning the blob
     const blobTypeDef = {
         read: (_cache, input) => {
             return ok({
-                data: input.data,
+                data: input.normalizedData,
             });
         },
         write: (_cache, input) => {
@@ -103580,6 +103645,16 @@
             // We should make this smarter, storing and returning blobs isn't great since it could, and likely will, include unrequested field data
             return blobTypeDef;
         }
+        satisfiesFragmentTypeCondition(input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
     }
 
     class SetupQueryAggregateRepository extends Setup__SetupQueryAggregateRepository {
@@ -103617,6 +103692,16 @@
             }
             return blobTypeDef;
         }
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
     }
 
     class PolymorphicParentRelationshipRepository extends PolymorphicParentRelationshipRepository$1 {
@@ -103627,26 +103712,242 @@
         }
     }
 
+    // We're going to override the generated repository
+    // to make this a pseudo-identifiable repository
+    // so that we can independently control its cache control (no-cache)
+    class SetupRepository extends IdentifiableGraphQLTypeRepository {
+        constructor(services, typeRegistry) {
+            super(services);
+            this.typeRegistry = typeRegistry;
+            this.namespace = 'oas';
+            this.typeName = 'Setup__Setup';
+            this.implementedInterfaces = [];
+            this.cacheControl = {
+                type: 'no-cache',
+            };
+            this.baseRepository = new Setup__SetupRepository(services, typeRegistry);
+        }
+        get fields() {
+            return this.baseRepository.fields;
+        }
+        buildKeyParams(_input) {
+            return null;
+        }
+        augmentSelections(input) {
+            return this.baseRepository.augmentSelections(input);
+        }
+    }
+
+    class SetupEdgeRepository extends Setup__SetupEdgeRepository {
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
+    }
+
+    class PolymorphicAggregateParentRelationshipRepository extends PolymorphicAggregateParentRelationshipRepository$1 {
+        getTypeDiscriminator(data, _selections) {
+            // Hardcoded to record aggregate since that's the only type of parent
+            // relationship possible
+            return 'RecordAggregate';
+        }
+    }
+
+    class RecordAggregateConnectionRepository extends RecordAggregateConnectionRepository$1 {
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
+    }
+
+    class RecordAggregateEdgeRepository extends RecordAggregateEdgeRepository$1 {
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
+    }
+
+    class RecordConnectionRepository extends RecordConnectionRepository$1 {
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
+    }
+
+    class RecordEdgeRepository extends RecordEdgeRepository$1 {
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
+    }
+
+    class RecordResultRepository extends RecordResultRepository$1 {
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
+    }
+
+    class SetupRecordResultRepository extends Setup__SetupRecordResultRepository {
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
+    }
+
+    class SetupAggregateConnectionRepository extends Setup__SetupAggregateConnectionRepository {
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
+    }
+
+    class SetupAggregateEdgeRepository extends Setup__SetupAggregateEdgeRepository {
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
+    }
+
+    class SetupConnectionRepository extends Setup__SetupConnectionRepository {
+        satisfiesFragmentTypeCondition(_input, fragment) {
+            const result = super.satisfiesFragmentTypeCondition(_input, fragment);
+            if (result.isErr()) {
+                return result;
+            }
+            if (result.value) {
+                return result;
+            }
+            return err(new Error(`${this.typeName}: unsupported fragment type condition: ${fragment.typeCondition?.name.value}`));
+        }
+    }
+
+    class SetupPolymorphicAggregateParentRelationshipRepository extends Setup__SetupPolymorphicAggregateParentRelationshipRepository {
+        getTypeDiscriminator(data, _selections) {
+            // Hardcoded to Setup__SetupRecordAggregate since that's the only type of parent
+            // relationship possible
+            return 'Setup__SetupRecordAggregate';
+        }
+    }
+
+    class SetupPolymorphicParentRelationshipRepository extends Setup__SetupPolymorphicParentRelationshipRepository {
+        getTypeDiscriminator(data, _selections) {
+            // Hardcoded to Setup__EntityRepresentation since that's the only type of parent
+            // relationship possible
+            return 'Setup__EntityRepresentation';
+        }
+    }
+
     class CustomGraphQLTypeRegistry extends GraphQLTypeRegistry {
         constructor(services) {
             super(services);
-            this._RecordRepresentation = new RecordRepresentationRepository(services, this);
+            // UIAPI Records overrides
             this._CompoundField = new CompoundFieldRepository(services, this);
-            this._RecordQuery = new RecordQueryRepository(services, this);
+            this._PolymorphicAggregateParentRelationship =
+                new PolymorphicAggregateParentRelationshipRepository(services, this);
+            this._PolymorphicParentRelationship = new PolymorphicParentRelationshipRepository(services, this);
+            this._RecordAggregateConnection = new RecordAggregateConnectionRepository(services, this);
+            this._RecordAggregateEdge = new RecordAggregateEdgeRepository(services, this);
             this._RecordAggregate = new RecordAggregateRepository(services, this);
+            this._RecordConnection = new RecordConnectionRepository(services, this);
+            this._RecordEdge = new RecordEdgeRepository(services, this);
             this._RecordQueryAggregate = new RecordQueryAggregateRepository(services, this);
+            this._RecordQuery = new RecordQueryRepository(services, this);
+            this._RecordRepresentation = new RecordRepresentationRepository(services, this);
+            this._RecordResult = new RecordResultRepository(services, this);
+            // Setup overrides
+            this._SetupAggregateConnection = new SetupAggregateConnectionRepository(services, this);
+            this._SetupAggregateEdge = new SetupAggregateEdgeRepository(services, this);
+            this._SetupConnection = new SetupConnectionRepository(services, this);
+            this._SetupEdge = new SetupEdgeRepository(services, this);
             this._SetupEntityRepresentation = new SetupEntityRepresentationRepository(services, this);
+            this._SetupPolymorphicAggregateParentRelationship =
+                new SetupPolymorphicAggregateParentRelationshipRepository(services, this);
+            this._SetupPolymorphicParentRelationship = new SetupPolymorphicParentRelationshipRepository(services, this);
             this._SetupQueryAggregate = new SetupQueryAggregateRepository(services, this);
             this._SetupQuery = new SetupQueryRepository(services, this);
             this._SetupRecordAggregate = new SetupRecordAggregateRepository(services, this);
-            this._PolymorphicParentRelationship = new PolymorphicParentRelationshipRepository(services, this);
+            this._SetupRecordResult = new SetupRecordResultRepository(services, this);
+            this._Setup = new SetupRepository(services, this);
         }
         get CompoundField() {
             return this._CompoundField;
         }
+        get PolymorphicAggregateParentRelationship() {
+            return this._PolymorphicAggregateParentRelationship;
+        }
+        get PolymorphicParentRelationship() {
+            return this._PolymorphicParentRelationship;
+        }
+        get RecordAggregateConnection() {
+            return this._RecordAggregateConnection;
+        }
+        get RecordAggregateEdge() {
+            return this._RecordAggregateEdge;
+        }
         get RecordAggregate() {
             return this._RecordAggregate;
         }
+        get RecordConnection() {
+            return this._RecordConnection;
+        }
+        get RecordEdge() {
+            return this._RecordEdge;
+        }
         get RecordQueryAggregate() {
             return this._RecordQueryAggregate;
         }
@@ -103656,20 +103957,44 @@
         get RecordRepresentation() {
             return this._RecordRepresentation;
         }
-        get SetupEntityRepresentation() {
+        get RecordResult() {
+            return this._RecordResult;
+        }
+        get Setup__SetupAggregateConnection() {
+            return this._SetupAggregateConnection;
+        }
+        get Setup__SetupAggregateEdge() {
+            return this._SetupAggregateEdge;
+        }
+        get Setup__SetupConnection() {
+            return this._SetupConnection;
+        }
+        get Setup__SetupEdge() {
+            return this._SetupEdge;
+        }
+        get Setup__EntityRepresentation() {
             return this._SetupEntityRepresentation;
         }
-        get SetupQueryAggregate() {
+        get Setup__SetupPolymorphicAggregateParentRelationship() {
+            return this._SetupPolymorphicAggregateParentRelationship;
+        }
+        get Setup__SetupPolymorphicParentRelationship() {
+            return this._SetupPolymorphicParentRelationship;
+        }
+        get Setup__SetupQueryAggregate() {
             return this._SetupQueryAggregate;
         }
-        get SetupQuery() {
+        get Setup__SetupQuery() {
             return this._SetupQuery;
         }
-        get SetupRecordAggregate() {
+        get Setup__SetupRecordAggregate() {
             return this._SetupRecordAggregate;
         }
-        get PolymorphicParentRelationship() {
-            return this._PolymorphicParentRelationship;
+        get Setup__SetupRecordResult() {
+            return this._SetupRecordResult;
+        }
+        get Setup__Setup() {
+            return this._Setup;
         }
     }
 
@@ -103821,10 +104146,12 @@
                             reader: true,
                             synthetic: true,
                             read: (reader) => {
+                                this.latestUsedRecordIdToWeakEtagMap = {};
                                 readFromCacheResult = this.buildResultType().query(cache, {
                                     ...this.buildQuery(),
                                     reader,
                                     getNormalizedLuvioRecord: this.services.luvioUiapiRecords.getNormalizedLuvioRecord,
+                                    usedRecordIdToWeakEtagMap: this.latestUsedRecordIdToWeakEtagMap,
                                 });
                                 return readFromCacheResult;
                             },
@@ -103876,15 +104203,20 @@
                 }
                 return resolvedPromiseLike(undefined);
             }
-            execute() {
+            execute(overrides) {
+                this.services.instrumentation?.metrics
+                    .getMeter('onestore')
+                    .createCounter(`graphql.execute.count`)
+                    .add(1);
                 // Clear snapshot and unsubscribe from any existing subscriptions at the beginning of execute calls
                 this.latestLuvioSnapshot = undefined;
                 this.latestLuvioRecordIdsToInvalidate = undefined;
+                this.latestUsedRecordIdToWeakEtagMap = undefined;
                 if (this.unsubscribeFromLuvioSnapshot) {
                     this.unsubscribeFromLuvioSnapshot();
                     this.unsubscribeFromLuvioSnapshot = undefined;
                 }
-                const result = super.execute();
+                const result = super.execute(overrides);
                 result.then((_) => {
                     if (this.latestLuvioRecordIdsToInvalidate &&
                         this.latestLuvioRecordIdsToInvalidate.length > 0) {
@@ -103893,6 +104225,13 @@
                 });
                 return result;
             }
+            runOriginalRequest() {
+                this.services.instrumentation?.metrics
+                    .getMeter('onestore')
+                    .createCounter(`graphql.fallback.count`)
+                    .add(1);
+                return super.runOriginalRequest();
+            }
             subscribeToKeysUsed() {
                 super.subscribeToKeysUsed();
                 // Subscribe to luvio cache changes using the stored snapshot
@@ -103903,12 +104242,48 @@
                         // Subscribe to changes using the stored snapshot
                         this.unsubscribeFromLuvioSnapshot = luvioInstance.storeSubscribe(this.latestLuvioSnapshot, (_) => {
                             // If any records used change at the top level, refresh all the data
-                            this.refresh();
+                            if (this.usedRecordsChanged()) {
+                                this.refresh();
+                            }
                         });
                     }
                     catch (error) { }
                 }
             }
+            usedRecordsChanged() {
+                if (!this.latestUsedRecordIdToWeakEtagMap ||
+                    Object.keys(this.latestUsedRecordIdToWeakEtagMap).length === 0) {
+                    return false;
+                }
+                const luvioService = this.services.luvio;
+                const luvioInstance = luvioService.luvio;
+                let dataChanged = false;
+                luvioInstance.storeLookup({
+                    recordId: 'onestore-graphql',
+                    node: {
+                        kind: 'Fragment',
+                        reader: true,
+                        synthetic: true,
+                        read: (reader) => {
+                            if (this.latestUsedRecordIdToWeakEtagMap) {
+                                Object.entries(this.latestUsedRecordIdToWeakEtagMap).forEach(([recordId, oneStoreRecordWeakEtag]) => {
+                                    const normalizedLuvioRecord = this.services.luvioUiapiRecords.getNormalizedLuvioRecord(recordId, reader);
+                                    if (!normalizedLuvioRecord) {
+                                        return;
+                                    }
+                                    const luvioRecordWeakEtag = normalizedLuvioRecord.weakEtag;
+                                    if (luvioRecordWeakEtag !== oneStoreRecordWeakEtag) {
+                                        dataChanged = true;
+                                    }
+                                });
+                            }
+                            return {};
+                        },
+                    },
+                    variables: {},
+                });
+                return dataChanged;
+            }
         };
     }
 
@@ -103955,6 +104330,11 @@
             type: 'luvioUiapiRecords',
             version: '1.0',
         },
+        instrumentation: {
+            type: 'instrumentation',
+            version: '1.0',
+            optional: true,
+        },
     };
     let provisionedCallback;
     getServices(serviceRequirements).then((services) => {
@@ -103965,7 +104345,7 @@
             constructor() {
                 super(...arguments);
                 this.configSchema = CONFIG_SCHEMA;
-                this.exposeRefresh = false;
+                this.exposeRefresh = true;
             }
             getCommand() {
                 return new graphql_ctor({ ...this.config, query: resolveAst(this.config.query) }, documentRootType, services);
@@ -103990,7 +104370,7 @@
             cb(graphql$1, graphql_imperative$1, useOneStoreGraphQL);
         }
     }
-    // version: 1.378.0-63d7c07562
+    // version: 1.379.0-a57c798add
 
     function createFragmentMap(documentNode) {
         const fragments = {};
@@ -130485,7 +130865,7 @@
         }
         return refresh$3(data, 'refreshUiApi');
     }
-    // version: 1.378.0-63d7c07562
+    // version: 1.379.0-a57c798add
 
     // On core the unstable adapters are re-exported with different names,
     // we want to match them here.
@@ -130637,7 +131017,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.378.0-63d7c07562
+    // version: 1.379.0-a57c798add
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -131436,7 +131816,7 @@
     function register(r) {
         callbacks$1.forEach((callback) => callback(r));
     }
-    // version: 1.378.0-0ab3d40d29
+    // version: 1.379.0-fc97fd9203
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -132773,4 +133153,4 @@
     exports.subscribeToAdapter = subscribeToAdapter;
 
 }));
-// version: 1.378.0-0ab3d40d29
+// version: 1.379.0-fc97fd9203