@salesforce/lds-worker-api 1.378.0 → 1.379.0

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

@@ -4274,7 +4274,7 @@ function withDefaultLuvio(callback) {
     }
     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) {
@@ -5318,7 +5318,7 @@ function createGraphQLWireAdapterConstructor(luvio, adapter, metadata, astResolv
     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.,
@@ -34154,7 +34154,7 @@ withDefaultLuvio((luvio) => {
     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) {
@@ -45764,15 +45764,6 @@ var graphqlL2AdapterGate = {
     },
 };
 
-var productConsumedSideEffects = {
-    isOpen: function (e) {
-        return e.fallback;
-    },
-    hasError: function () {
-        return !0;
-    },
-};
-
 var useOneStore = {
     isOpen: function (e) {
         return e.fallback;
@@ -46117,6 +46108,15 @@ function buildReadWriteResult(data, errors) {
   return ok$4(data);
 }
 
+var productConsumedSideEffects = {
+    isOpen: function (e) {
+        return e.fallback;
+    },
+    hasError: function () {
+        return !0;
+    },
+};
+
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
  * All rights reserved.
@@ -95881,7 +95881,7 @@ function buildServiceDescriptor$5(luvio) {
         },
     };
 }
-// version: 1.378.0-63d7c07562
+// version: 1.379.0-a57c798add
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -95907,7 +95907,7 @@ function buildServiceDescriptor$4(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.378.0-63d7c07562
+// version: 1.379.0-a57c798add
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -98023,7 +98023,7 @@ register$1({
     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;
@@ -99402,7 +99402,11 @@ class BaseGraphQLTypeRepository {
   }
   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({
@@ -99428,7 +99432,11 @@ class BaseGraphQLTypeRepository {
     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({
@@ -99541,10 +99549,7 @@ class BaseGraphQLTypeRepository {
     };
   }
   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",
@@ -99675,10 +99680,7 @@ class BaseGraphQLTypeRepository {
     };
   }
   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",
@@ -99716,28 +99718,28 @@ class BaseGraphQLTypeRepository {
     }
     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;
@@ -100466,10 +100468,11 @@ class GraphQLCommandWireAdapterConstructor extends CommandWireAdapterConstructor
   }
 }
 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);
       }
@@ -100478,11 +100481,12 @@ function buildAsyncGraphQLImperativeLegacyInvoker(getCommand) {
       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;
@@ -100498,7 +100502,10 @@ function buildAsyncGraphQLImperativeLegacyInvoker(getCommand) {
   };
   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) {
@@ -100710,7 +100717,14 @@ class AnyTypeRepository extends BaseUnionRepository {
         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,
@@ -100718,11 +100732,6 @@ class AnyTypeRepository extends BaseUnionRepository {
             StringValue: this.typeRegistry.StringValue,
         };
     }
-    get fields() {
-        return {
-            __typename: new BaseScalarFieldDef(false),
-        };
-    }
 }
 
 class Base64ValueRepository extends UnidentifiableGraphQLTypeRepository {
@@ -101655,7 +101664,7 @@ class PicklistValueRepository extends UnidentifiableGraphQLTypeRepository {
     }
 }
 
-class PolymorphicAggregateParentRelationshipRepository extends BaseUnionRepository {
+let PolymorphicAggregateParentRelationshipRepository$1 = class PolymorphicAggregateParentRelationshipRepository extends BaseUnionRepository {
     constructor(services, typeRegistry) {
         super(services);
         this.services = services;
@@ -101663,16 +101672,18 @@ class PolymorphicAggregateParentRelationshipRepository extends BaseUnionReposito
         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) {
@@ -101682,15 +101693,17 @@ let PolymorphicParentRelationshipRepository$1 = class PolymorphicParentRelations
         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 {
@@ -101715,7 +101728,7 @@ class QueryRepository extends GraphQLDocumentRootTypeRepository {
     }
 }
 
-class RecordAggregateConnectionRepository extends UnidentifiableGraphQLTypeRepository {
+let RecordAggregateConnectionRepository$1 = class RecordAggregateConnectionRepository extends UnidentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
         super(services);
         this.services = services;
@@ -101732,9 +101745,9 @@ class RecordAggregateConnectionRepository extends UnidentifiableGraphQLTypeRepos
             totalCount: new BaseScalarFieldDef(false),
         };
     }
-}
+};
 
-class RecordAggregateEdgeRepository extends UnidentifiableGraphQLTypeRepository {
+let RecordAggregateEdgeRepository$1 = class RecordAggregateEdgeRepository extends UnidentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
         super(services);
         this.services = services;
@@ -101750,7 +101763,7 @@ class RecordAggregateEdgeRepository extends UnidentifiableGraphQLTypeRepository
             cursor: new BaseScalarFieldDef(false),
         };
     }
-}
+};
 
 let RecordAggregateRepository$1 = class RecordAggregateRepository extends UnidentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
@@ -101788,7 +101801,7 @@ let RecordAggregateRepository$1 = class RecordAggregateRepository extends Uniden
     }
 };
 
-class RecordConnectionRepository extends UnidentifiableGraphQLTypeRepository {
+let RecordConnectionRepository$1 = class RecordConnectionRepository extends UnidentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
         super(services);
         this.services = services;
@@ -101806,9 +101819,9 @@ class RecordConnectionRepository extends UnidentifiableGraphQLTypeRepository {
             pageResultCount: new BaseScalarFieldDef(false),
         };
     }
-}
+};
 
-class RecordEdgeRepository extends UnidentifiableGraphQLTypeRepository {
+let RecordEdgeRepository$1 = class RecordEdgeRepository extends UnidentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
         super(services);
         this.services = services;
@@ -101824,7 +101837,7 @@ class RecordEdgeRepository extends UnidentifiableGraphQLTypeRepository {
             cursor: new BaseScalarFieldDef(false),
         };
     }
-}
+};
 
 let RecordQueryAggregateRepository$1 = class RecordQueryAggregateRepository extends UnidentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
@@ -101919,7 +101932,7 @@ let RecordRepresentationRepository$1 = class RecordRepresentationRepository exte
     }
 };
 
-class RecordResultRepository extends UnidentifiableGraphQLTypeRepository {
+let RecordResultRepository$1 = class RecordResultRepository extends UnidentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
         super(services);
         this.services = services;
@@ -101934,7 +101947,7 @@ class RecordResultRepository extends UnidentifiableGraphQLTypeRepository {
             aggregate: new BaseObjectFieldDef(this.typeRegistry.RecordAggregate, true),
         };
     }
-}
+};
 
 class RecordTypeInfoRepository extends UnidentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
@@ -102357,15 +102370,17 @@ class Setup__SetupPolymorphicAggregateParentRelationshipRepository extends BaseU
         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 {
@@ -102376,15 +102391,17 @@ class Setup__SetupPolymorphicParentRelationshipRepository extends BaseUnionRepos
         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 {
@@ -102734,10 +102751,10 @@ class GraphQLTypeRegistry {
         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);
@@ -102767,13 +102784,13 @@ class GraphQLTypeRegistry {
         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 =
@@ -103323,9 +103340,19 @@ class RecordRepresentationBaseRepository extends BaseGraphQLTypeRepository {
             '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 {
@@ -103348,15 +103375,26 @@ class RecordRepresentationRepository extends RecordRepresentationRepository$1 {
         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);
@@ -103369,13 +103407,18 @@ class RecordRepresentationRepository extends RecordRepresentationRepository$1 {
     }
     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;
     }
@@ -103468,6 +103511,16 @@ class CompoundFieldRepository extends CompoundFieldRepository$1 {
     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 {
@@ -103489,6 +103542,16 @@ class RecordAggregateRepository extends RecordAggregateRepository$1 {
     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 {
@@ -103503,10 +103566,12 @@ class RecordQueryAggregateRepository extends RecordQueryAggregateRepository$1 {
     }
 }
 
+// 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) => {
@@ -103574,6 +103639,16 @@ class SetupEntityRepresentationRepository extends UnidentifiableGraphQLTypeRepos
         // 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 {
@@ -103611,6 +103686,16 @@ class SetupRecordAggregateRepository extends Setup__SetupRecordAggregateReposito
         }
         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 {
@@ -103621,26 +103706,242 @@ class PolymorphicParentRelationshipRepository extends PolymorphicParentRelations
     }
 }
 
+// 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;
     }
@@ -103650,20 +103951,44 @@ class CustomGraphQLTypeRegistry extends GraphQLTypeRegistry {
     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;
     }
 }
 
@@ -103815,10 +104140,12 @@ function buildCommandClass(baseClass) {
                         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;
                         },
@@ -103870,15 +104197,20 @@ function buildCommandClass(baseClass) {
             }
             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) {
@@ -103887,6 +104219,13 @@ function buildCommandClass(baseClass) {
             });
             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
@@ -103897,12 +104236,48 @@ function buildCommandClass(baseClass) {
                     // 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;
+        }
     };
 }
 
@@ -103949,6 +104324,11 @@ const serviceRequirements = {
         type: 'luvioUiapiRecords',
         version: '1.0',
     },
+    instrumentation: {
+        type: 'instrumentation',
+        version: '1.0',
+        optional: true,
+    },
 };
 let provisionedCallback;
 getServices(serviceRequirements).then((services) => {
@@ -103959,7 +104339,7 @@ getServices(serviceRequirements).then((services) => {
         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);
@@ -103984,7 +104364,7 @@ function registerCallback(cb) {
         cb(graphql$1, graphql_imperative$1, useOneStoreGraphQL);
     }
 }
-// version: 1.378.0-63d7c07562
+// version: 1.379.0-a57c798add
 
 function createFragmentMap(documentNode) {
     const fragments = {};
@@ -130479,7 +130859,7 @@ function refreshGraphQL(data) {
     }
     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.
@@ -130631,7 +131011,7 @@ withDefaultLuvio((luvio) => {
     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,
@@ -131430,7 +131810,7 @@ const callbacks$1 = [];
 function register(r) {
     callbacks$1.forEach((callback) => callback(r));
 }
-// version: 1.378.0-0ab3d40d29
+// version: 1.379.0-fc97fd9203
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -132746,4 +133126,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.378.0-0ab3d40d29
+// version: 1.379.0-fc97fd9203