@salesforce/lds-worker-api 1.382.0 → 1.384.0

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

@@ -4274,7 +4274,7 @@ function withDefaultLuvio(callback) {
     }
     callbacks.push(callback);
 }
-// version: 1.382.0-8ca71123b0
+// version: 1.384.0-cb845692ac
 
 // 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.382.0-8ca71123b0
+// version: 1.384.0-cb845692ac
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -34154,7 +34154,7 @@ withDefaultLuvio((luvio) => {
     throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
     throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
 });
-// version: 1.382.0-73d929ea11
+// version: 1.384.0-835fd13f44
 
 function requestIdleDetectedCallback(_callback) { }
 function declareNotifierTaskSingle(_name) {
@@ -81030,6 +81030,16 @@ function reportAggressiveTrimTriggered(trimCount, beforeTrimRecordCount, totalRe
     ldsMobileInstrumentation$2.trackValue(GARBAGE_COLLECTION_AGGRESSIVE_TRIM_TOTAL_RECORDS_BEFORE_TRIM, beforeTrimRecordCount);
     ldsMobileInstrumentation$2.trackValue(GARBAGE_COLLECTION_AGGRESSIVE_TRIM_RECORDS_TRIMMED, totalRecordsTrimmed);
 }
+/** One Store Cache Purge */
+const ONESTORE_CACHE_PURGING_RECORDS_PURGED = 'onestore-cache-purging-records-purged';
+const ONESTORE_CACHE_PURGING_RECORDS_ERROR = 'onestore-cache-purging-records-error';
+function reportOneStoreRecordsPurgedFromCache(recordsPurged) {
+    ldsMobileInstrumentation$2.trackValue(ONESTORE_CACHE_PURGING_RECORDS_PURGED, recordsPurged);
+}
+function reportOneStoreCachePurgingError(error) {
+    const errorMessage = normalizeError$1(error);
+    ldsMobileInstrumentation$2.error(errorMessage, ONESTORE_CACHE_PURGING_RECORDS_ERROR);
+}
 
 const QUICK_ACTION_HANDLER = 'QUICK_ACTION_HANDLER';
 class QuickActionExecutionRepresentationHandler extends AbstractQuickActionHandler {
@@ -94268,7 +94278,7 @@ class CacheControlRequestRunner {
   }
   requestFromNetwork() {
     const that = this;
-    return async function* () {
+    return (async function* () {
       const result = await that.requestFromNetworkInternal();
       if (result.isErr()) {
         that.networkError = result;
@@ -94276,7 +94286,7 @@ class CacheControlRequestRunner {
         that.networkData = result;
       }
       yield result;
-    }();
+    })();
   }
   writeToCache(cache, networkResult) {
     return this.writeToCacheInternal(cache, networkResult);
@@ -95881,7 +95891,7 @@ function buildServiceDescriptor$5(luvio) {
         },
     };
 }
-// version: 1.382.0-73d929ea11
+// version: 1.384.0-835fd13f44
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -95907,7 +95917,7 @@ function buildServiceDescriptor$4(notifyRecordUpdateAvailable, getNormalizedLuvi
         },
     };
 }
-// version: 1.382.0-73d929ea11
+// version: 1.384.0-835fd13f44
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -96752,7 +96762,7 @@ function hasMultilineItems(maybeArray) {
  * All rights reserved.
  * For full license text, see the LICENSE.txt file
  */
-function findExecutableOperation$1(input) {
+function findExecutableOperation$2(input) {
   const operations = input.query.definitions.filter(
     (def) => def.kind === Kind$2.OPERATION_DEFINITION
   );
@@ -96775,7 +96785,7 @@ function findExecutableOperation$1(input) {
   return err$1$1(new Error("Multiple operations found in query, and no operation name provided"));
 }
 function buildGraphQLInputExtension$1(input) {
-  const operationResult = findExecutableOperation$1(input);
+  const operationResult = findExecutableOperation$2(input);
   if (operationResult.isErr()) {
     return err$1$1(operationResult.error);
   }
@@ -96790,7 +96800,7 @@ function buildGraphQLInputExtension$1(input) {
     };
     return prev;
   }, {})) || {};
-  const fragments = input.query.definitions.filter((def) => def.kind === "FragmentDefinition").reduce((prev, fragment) => {
+  const fragments = input.query.definitions.filter(isFragmentDefinition$1).reduce((prev, fragment) => {
     prev[fragment.name.value] = fragment;
     return prev;
   }, {});
@@ -96800,6 +96810,47 @@ function buildGraphQLInputExtension$1(input) {
     parentFieldSelection: void 0
   });
 }
+const TYPENAME_FIELD = {
+  kind: Kind$2.FIELD,
+  name: {
+    kind: Kind$2.NAME,
+    value: "__typename"
+  }
+};
+function addTypenameToDocument(doc) {
+  return visit(doc, {
+    SelectionSet: {
+      enter(node, _key, parent) {
+        if (isOperationDefinition(parent)) {
+          return;
+        }
+        const { selections } = node;
+        if (!selections || selections.length === 0) {
+          return;
+        }
+        const skip = selections.some((selection) => {
+          return isField$1(selection) && (selection.name.value === "__typename" || selection.name.value.lastIndexOf("__", 0) === 0);
+        });
+        if (skip) {
+          return;
+        }
+        return {
+          ...node,
+          selections: [...selections, TYPENAME_FIELD]
+        };
+      }
+    }
+  });
+}
+function isOperationDefinition(parent) {
+  return !!parent && !Array.isArray(parent) && parent.kind === Kind$2.OPERATION_DEFINITION;
+}
+function isField$1(node) {
+  return node.kind === Kind$2.FIELD;
+}
+function isFragmentDefinition$1(node) {
+  return node.kind === Kind$2.FRAGMENT_DEFINITION;
+}
 
 /*!
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -96923,7 +96974,7 @@ class AuraGraphQLNormalizedCacheControlCommand extends AuraNormalizedCacheContro
     if (augmentedQueryResult.isErr()) {
       throw augmentedQueryResult.error;
     }
-    return augmentedQueryResult.value;
+    return addTypenameToDocument(augmentedQueryResult.value);
   }
   buildWriteInput(data) {
     const extensionResult = buildGraphQLInputExtension$1({
@@ -97017,7 +97068,7 @@ class HttpGraphQLNormalizedCacheControlCommand extends HttpNormalizedCacheContro
     if (augmentedQueryResult.isErr()) {
       throw augmentedQueryResult.error;
     }
-    return augmentedQueryResult.value;
+    return addTypenameToDocument(augmentedQueryResult.value);
   }
   buildWriteInput(data) {
     const extensionResult = buildGraphQLInputExtension$1({
@@ -97771,6 +97822,7 @@ class NimbusSqliteOneStoreCache {
     }
 }
 
+const PURGE_CACHE_DAYS = 30;
 // TODO[@W-18753648]: These services depend on WebApis that aren't available in the worker.
 // import { buildServiceDescriptor as buildNdJsonServiceDescriptor } from '@luvio/command-ndjson/v1';
 // import { buildServiceDescriptor as buildStreamingCommandServiceDescriptor } from '@luvio/command-streaming/v1';
@@ -97819,6 +97871,48 @@ function initializeOneStore(sqliteStore) {
         // buildSseCommandServiceDescriptor(),
     ];
     setServices(services);
+    purgeDurableCacheByDays(PURGE_CACHE_DAYS, sqliteStore);
+}
+/**
+ * Manually purges the OneStore cache by days.
+ * Until we have real cache eviction in one store.
+ *
+ * @param days - The number of days to purge the cache by.
+ * @param sqliteStore - The SqliteStorePlugin to purge the cache from.
+ */
+async function purgeDurableCacheByDays(days, sqliteStore) {
+    const MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1000;
+    const cutoffTimestamp = Date.now() - days * MILLISECONDS_PER_DAY;
+    try {
+        // This has to be ran in a SELECT since the DELETE query may not support return on SQLite version in mobile
+        const countQuery = `
+            SELECT COUNT(*) FROM lds_one_store_data
+            WHERE json_extract(metadata, '$.cacheControl.generatedTime') < ?
+        `;
+        const countResult = await queryAsync(sqliteStore, countQuery, [cutoffTimestamp]);
+        const deleteCount = countResult.rows[0][0];
+        if (deleteCount === 0) {
+            reportOneStoreRecordsPurgedFromCache(0);
+            return;
+        }
+        const deleteQuery = `
+            DELETE FROM lds_one_store_data
+            WHERE json_extract(metadata, '$.cacheControl.generatedTime') < ?
+        `;
+        await queryAsync(sqliteStore, deleteQuery, [cutoffTimestamp]);
+        reportOneStoreRecordsPurgedFromCache(deleteCount);
+    }
+    catch (error) {
+        reportOneStoreCachePurgingError(error);
+    }
+}
+/**
+ * Promisified wrapper for SqliteStorePlugin.query
+ */
+function queryAsync(sqliteStore, sql, params) {
+    return new Promise((resolve, reject) => {
+        sqliteStore.query(sql, params, (result) => resolve(result), (error) => reject(error));
+    });
 }
 
 // so eslint doesn't complain about nimbus
@@ -98023,7 +98117,7 @@ register$1({
     id: '@salesforce/lds-network-adapter',
     instrument: instrument$2,
 });
-// version: 1.382.0-8ca71123b0
+// version: 1.384.0-cb845692ac
 
 const { create: create$3, keys: keys$3 } = Object;
 const { stringify: stringify$1, parse } = JSON;
@@ -98943,7 +99037,7 @@ function deepMerge$2(target, ...sources) {
   }
   return target;
 }
-function findExecutableOperation(input) {
+function findExecutableOperation$1(input) {
   const operations = input.query.definitions.filter(
     (def) => def.kind === Kind.OPERATION_DEFINITION
   );
@@ -98966,7 +99060,7 @@ function findExecutableOperation(input) {
   return err$3(new Error("Multiple operations found in query, and no operation name provided"));
 }
 function buildGraphQLInputExtension(input) {
-  const operationResult = findExecutableOperation(input);
+  const operationResult = findExecutableOperation$1(input);
   if (operationResult.isErr()) {
     return err$3(operationResult.error);
   }
@@ -98981,7 +99075,7 @@ function buildGraphQLInputExtension(input) {
     };
     return prev;
   }, {})) || {};
-  const fragments = input.query.definitions.filter((def) => def.kind === "FragmentDefinition").reduce((prev, fragment) => {
+  const fragments = input.query.definitions.filter(isFragmentDefinition).reduce((prev, fragment) => {
     prev[fragment.name.value] = fragment;
     return prev;
   }, {});
@@ -98991,14 +99085,24 @@ function buildGraphQLInputExtension(input) {
     parentFieldSelection: void 0
   });
 }
-function buildUniqueAugmentedFieldSelection(newSelection, selections, fragments) {
+function buildAugmentedFieldSelection(newSelection, selections, fragments) {
   var _a;
+  if (selectionExists(newSelection, selections)) {
+    return void 0;
+  }
   const baseAlias = ((_a = newSelection.alias) == null ? void 0 : _a.value) || newSelection.name.value;
   const baseInjectedAlias = `framework_augmented_${baseAlias}`;
-  const fieldName = getUniqueSelectionName(baseInjectedAlias, selections, fragments);
-  if (fieldName === newSelection.name.value) {
-    return newSelection;
+  const baseAliasedSelection = {
+    ...newSelection,
+    alias: {
+      kind: Kind.NAME,
+      value: baseInjectedAlias
+    }
+  };
+  if (selectionExists(baseAliasedSelection, selections)) {
+    return void 0;
   }
+  const fieldName = getUniqueSelectionName(baseInjectedAlias, selections, fragments);
   return {
     ...newSelection,
     alias: {
@@ -99007,6 +99111,94 @@ function buildUniqueAugmentedFieldSelection(newSelection, selections, fragments)
     }
   };
 }
+function selectionExists(selection, selections) {
+  return selections.some((s) => selectionEquals(selection, s));
+}
+function selectionEquals(a, b) {
+  var _a, _b, _c, _d, _e, _f;
+  if (a.kind !== b.kind) {
+    return false;
+  }
+  if (a.kind === Kind.FIELD) {
+    const bField = b;
+    return !!(a.name.value === bField.name.value) && !!(((_a = a.alias) == null ? void 0 : _a.value) === ((_b = bField.alias) == null ? void 0 : _b.value)) && argumentsEqual(a.arguments, bField.arguments) && selectionSetsEqual((_c = a.selectionSet) == null ? void 0 : _c.selections, (_d = bField.selectionSet) == null ? void 0 : _d.selections) && directivesEqual(a.directives, bField.directives);
+  }
+  if (a.kind === Kind.FRAGMENT_SPREAD) {
+    const bFragmentSpread = b;
+    return a.name.value === bFragmentSpread.name.value && directivesEqual(a.directives, bFragmentSpread.directives);
+  }
+  const bInlineFragment = b;
+  return a.typeCondition === bInlineFragment.typeCondition && directivesEqual(a.directives, bInlineFragment.directives) && selectionSetsEqual((_e = a.selectionSet) == null ? void 0 : _e.selections, (_f = bInlineFragment.selectionSet) == null ? void 0 : _f.selections);
+}
+function argumentValueEquals(a, b) {
+  if (a.kind !== b.kind) {
+    return false;
+  }
+  switch (a.kind) {
+    case Kind.STRING:
+    case Kind.INT:
+    case Kind.FLOAT:
+    case Kind.BOOLEAN:
+    case Kind.ENUM:
+      return a.value === b.value;
+    case Kind.NULL:
+      return true;
+    case Kind.VARIABLE:
+      return a.name.value === b.name.value;
+    case Kind.LIST:
+      const bList = b;
+      if (a.values.length !== bList.values.length) {
+        return false;
+      }
+      return a.values.every((val, index) => argumentValueEquals(val, bList.values[index]));
+    case Kind.OBJECT:
+      const bObject = b;
+      if (a.fields.length !== bObject.fields.length) {
+        return false;
+      }
+      return a.fields.every((field, index) => {
+        const bField = bObject.fields[index];
+        return field.name.value === bField.name.value && argumentValueEquals(field.value, bField.value);
+      });
+    default:
+      return false;
+  }
+}
+function directivesEqual(a, b) {
+  if (a === void 0 && b === void 0) {
+    return true;
+  }
+  if (a === void 0 || b === void 0) {
+    return ((a == null ? void 0 : a.length) || 0) === ((b == null ? void 0 : b.length) || 0);
+  }
+  if (a.length !== b.length) {
+    return false;
+  }
+  return a.every((directive, index) => {
+    const bDirective = b[index];
+    return directive.name.value === bDirective.name.value && argumentsEqual(directive.arguments, bDirective.arguments);
+  });
+}
+function argumentsEqual(a, b) {
+  if (a === void 0 && b === void 0) {
+    return true;
+  }
+  if (a === void 0 || b === void 0) {
+    return ((a == null ? void 0 : a.length) || 0) === ((b == null ? void 0 : b.length) || 0);
+  }
+  if (a.length !== b.length) {
+    return false;
+  }
+  return a.every((arg, index) => {
+    const bArg = b[index];
+    return arg.name.value === bArg.name.value && argumentValueEquals(arg.value, bArg.value);
+  });
+}
+function selectionSetsEqual(a, b) {
+  return a === void 0 || b === void 0 || !!(a.length === b.length) && !!a.every((selection, index) => {
+    return selectionEquals(selection, b[index]);
+  });
+}
 function getUniqueSelectionName(fieldName, selections, fragments) {
   const fieldNames = collectFieldNames(selections, fragments);
   if (!fieldNames.includes(fieldName)) {
@@ -99022,14 +99214,14 @@ function collectFieldNames(selections, fragments) {
   var _a;
   const fieldNames = /* @__PURE__ */ new Set();
   for (const selection of selections) {
-    if (selection.kind === Kind.FIELD) {
+    if (isField(selection)) {
       fieldNames.add(((_a = selection.alias) == null ? void 0 : _a.value) || selection.name.value);
-    } else if (selection.kind === Kind.INLINE_FRAGMENT) {
+    } else if (isInlineFragment(selection)) {
       collectFieldNames(
         selection.selectionSet.selections,
         fragments
       ).forEach((name) => fieldNames.add(name));
-    } else if (selection.kind === Kind.FRAGMENT_SPREAD) {
+    } else if (isFragmentSpread(selection)) {
       const fragment = fragments[selection.name.value];
       if (fragment) {
         collectFieldNames(
@@ -99059,6 +99251,25 @@ function buildFieldKey(canonicalFieldName, fieldArguments, variables) {
   }
   return ok$4(`${canonicalFieldName}::${stableJSONStringify$3({ args: formattedArguments })}`);
 }
+({
+  kind: Kind.FIELD,
+  name: {
+    kind: Kind.NAME,
+    value: "__typename"
+  }
+});
+function isField(node) {
+  return node.kind === Kind.FIELD;
+}
+function isFragmentSpread(node) {
+  return node.kind === Kind.FRAGMENT_SPREAD;
+}
+function isInlineFragment(node) {
+  return node.kind === Kind.INLINE_FRAGMENT;
+}
+function isFragmentDefinition(node) {
+  return node.kind === Kind.FRAGMENT_DEFINITION;
+}
 function extractIfArgument(directive, variables, directiveName) {
   var _a;
   const ifArg = (_a = directive.arguments) == null ? void 0 : _a.find((arg) => arg.name.value === "if");
@@ -99342,11 +99553,11 @@ class BaseGraphQLTypeRepository {
     const augmentedSelections = [];
     let augmentedFragments = { ...input.fragments };
     for (const selection of input.selections) {
-      if (selection.kind === Kind.FIELD) {
+      if (isField(selection)) {
         const result = this.augmentFieldSelection(selection, augmentedFragments);
         augmentedSelections.push(...result.selections);
         augmentedFragments = result.fragments;
-      } else if (selection.kind === Kind.INLINE_FRAGMENT) {
+      } else if (isInlineFragment(selection)) {
         const augmentedFragmentSelections = this.augmentInlineFragmentSelection(
           selection,
           augmentedFragments
@@ -99362,19 +99573,20 @@ class BaseGraphQLTypeRepository {
         augmentedFragments = augmentedFragmentSelections.fragments;
       }
     }
-    augmentedSelections.push(
-      buildUniqueAugmentedFieldSelection(
-        {
-          kind: Kind.FIELD,
-          name: {
-            kind: Kind.NAME,
-            value: "__typename"
-          }
-        },
-        [...augmentedSelections, ...input.selections],
-        augmentedFragments
-      )
+    const newTypenameSelection = buildAugmentedFieldSelection(
+      {
+        kind: Kind.FIELD,
+        name: {
+          kind: Kind.NAME,
+          value: "__typename"
+        }
+      },
+      [...augmentedSelections, ...input.selections],
+      augmentedFragments
     );
+    if (newTypenameSelection) {
+      augmentedSelections.push(newTypenameSelection);
+    }
     return { selections: augmentedSelections, fragments: augmentedFragments };
   }
   augmentFieldSelection(selection, fragments) {
@@ -99437,21 +99649,21 @@ class BaseGraphQLTypeRepository {
       fragment
     );
     if (satisfiedFragmentTypeConditionResult.isErr() || !satisfiedFragmentTypeConditionResult.value) {
-      return { selections: [], fragments };
+      return { selections: [selection], fragments };
     }
-    const augmentedFragmentSelections = this.augmentSelections({
+    const augmentedFragment = this.augmentSelections({
       selections: ((_a = fragment.selectionSet) == null ? void 0 : _a.selections) || [],
       fragments
     });
     return {
       selections: [selection],
       fragments: {
-        ...fragments,
+        ...augmentedFragment.fragments,
         [fragment.name.value]: {
           ...fragment,
           selectionSet: {
             kind: Kind.SELECTION_SET,
-            selections: augmentedFragmentSelections.selections
+            selections: augmentedFragment.selections
           }
         }
       }
@@ -99461,14 +99673,14 @@ class BaseGraphQLTypeRepository {
     const normalized = {};
     const errors = [];
     for (const selection of input.selections) {
-      if (selection.kind === Kind.FIELD) {
+      if (isField(selection)) {
         deepMerge$2(
           normalized,
           this.normalizeFieldSelection(cache, input, selection, errors)
         );
       } else {
         let fragment;
-        if (selection.kind === Kind.INLINE_FRAGMENT) {
+        if (isInlineFragment(selection)) {
           fragment = selection;
         } else {
           const fragmentDefinition = input.request.definitions.fragments[selection.name.value];
@@ -99573,14 +99785,14 @@ class BaseGraphQLTypeRepository {
     const errors = [];
     const denormalized = {};
     for (const selection of input.selections) {
-      if (selection.kind === Kind.FIELD) {
+      if (isField(selection)) {
         deepMerge$2(
           denormalized,
           this.denormalizeFieldSelection(cache, input, selection, errors)
         );
       } else {
         let fragment;
-        if (selection.kind === Kind.INLINE_FRAGMENT) {
+        if (isInlineFragment(selection)) {
           fragment = selection;
         } else {
           const fragmentDefinition = input.request.definitions.fragments[selection.name.value];
@@ -99770,19 +99982,20 @@ class IdentifiableGraphQLTypeRepository extends IdentifiableTypeRepository {
         const result = super.augmentSelections(input);
         const augmentedSelections = result.selections;
         let augmentedFragments = result.fragments;
-        augmentedSelections.push(
-          buildUniqueAugmentedFieldSelection(
-            {
-              kind: Kind.FIELD,
-              name: {
-                kind: Kind.NAME,
-                value: this.idField
-              }
-            },
-            [...augmentedSelections, ...input.selections],
-            augmentedFragments
-          )
+        const newSelection = buildAugmentedFieldSelection(
+          {
+            kind: Kind.FIELD,
+            name: {
+              kind: Kind.NAME,
+              value: this.idField
+            }
+          },
+          [...augmentedSelections, ...input.selections],
+          augmentedFragments
         );
+        if (newSelection) {
+          augmentedSelections.push(newSelection);
+        }
         return { selections: augmentedSelections, fragments: augmentedFragments };
       }
     };
@@ -99838,6 +100051,19 @@ class IdentifiableGraphQLTypeRepository extends IdentifiableTypeRepository {
   buildFieldKey(selection, variables) {
     return this.graphqlRepository.buildFieldKey(selection, variables);
   }
+  buildKeyParams(input) {
+    var _a;
+    const idField = input.selections.find(
+      (selection) => selection.kind === Kind.FIELD && selection.name.value === this.idField
+    );
+    if (!idField) {
+      throw new Error(`Id field ${this.idField} not found in selections`);
+    }
+    const idFieldDataProperty = ((_a = idField.alias) == null ? void 0 : _a.value) || idField.name.value;
+    return {
+      [this.idField]: input.data[idFieldDataProperty]
+    };
+  }
 }
 class GraphQLDocumentRootTypeRepository extends IdentifiableGraphQLTypeRepository {
   constructor() {
@@ -99884,7 +100110,7 @@ class GraphQLDocumentRootTypeRepository extends IdentifiableGraphQLTypeRepositor
   }
   buildAugmentedQuery(input) {
     var _a;
-    const operationResult = findExecutableOperation(input);
+    const operationResult = findExecutableOperation$1(input);
     if (operationResult.isErr()) {
       return err$3(operationResult.error);
     }
@@ -100029,13 +100255,14 @@ class BaseUnionRepository {
     );
     augmentedSelections.push(...result.selections);
     augmentedFragments = result.fragments;
-    augmentedSelections.push(
-      buildUniqueAugmentedFieldSelection(
-        { kind: Kind.FIELD, name: { kind: Kind.NAME, value: "__typename" } },
-        augmentedSelections,
-        input.fragments
-      )
+    const newSelection = buildAugmentedFieldSelection(
+      { kind: Kind.FIELD, name: { kind: Kind.NAME, value: "__typename" } },
+      augmentedSelections,
+      input.fragments
     );
+    if (newSelection) {
+      augmentedSelections.push(newSelection);
+    }
     return { selections: augmentedSelections, fragments: augmentedFragments };
   }
   getTypeDiscriminator(data, _selections) {
@@ -100383,6 +100610,56 @@ function isIncompleteConfigError(err) {
     (validationError) => validationError instanceof MissingRequiredPropertyError
   ) !== void 0;
 }
+function findExecutableOperation(document, operationName) {
+  const operations = document.definitions.filter(
+    (def) => def.kind === Kind$1.OPERATION_DEFINITION
+  );
+  if (operations.length === 0) {
+    return void 0;
+  }
+  if (operations.length === 1 && !operationName) {
+    return operations[0];
+  }
+  if (operationName) {
+    return operations.find((op) => {
+      var _a;
+      return ((_a = op.name) == null ? void 0 : _a.value) === operationName;
+    });
+  }
+  return void 0;
+}
+function validateGraphQLOperations(config, options) {
+  const executableOperation = findExecutableOperation(config.query, config.operationName);
+  if (executableOperation) {
+    const operationType = executableOperation.operation;
+    if (!options.acceptedOperations.includes(operationType)) {
+      const operationTypeCapitalized = operationType.charAt(0).toUpperCase() + operationType.slice(1);
+      throw new Error(
+        `${operationTypeCapitalized} operations are not supported in this context`
+      );
+    }
+  }
+}
+function resolveAst(ast) {
+  if (ast === null) {
+    return;
+  }
+  const result = astResolver(ast);
+  if (result === void 0) {
+    throw new Error("Could not resolve AST. Did you parse the query with gql?");
+  }
+  return result;
+}
+function wrapConfigAndVerify(config) {
+  if (config == null ? void 0 : config.query) {
+    config = { ...config, query: resolveAst(config.query) };
+    if (config.query === void 0) {
+      throw new Error("Internal error in GraphQL adapter occurred: Unable to resolve query");
+    }
+    validateGraphQLOperations(config, { acceptedOperations: ["query"] });
+  }
+  return config;
+}
 class GraphQLCommandWireAdapterConstructor extends CommandWireAdapterConstructor {
   emit(result) {
     try {
@@ -100451,15 +100728,110 @@ class GraphQLCommandWireAdapterConstructor extends CommandWireAdapterConstructor
   }
   update(config, _context) {
     this.unsubscribe();
+    const resolvedQuery = resolveAst(config.query);
+    if (resolvedQuery) {
+      validateGraphQLOperations(
+        { query: resolvedQuery, operationName: config == null ? void 0 : config.operationName },
+        { acceptedOperations: ["query"] }
+      );
+    }
     this.config = {
       ...sanitize(config),
-      query: config.query
+      query: resolvedQuery
     };
     this.invokeAdapter();
   }
 }
+function buildAsyncGraphQLImperativeInvoker(getCommand, exposeRefresh = false) {
+  return async (...params) => {
+    try {
+      if (params.length) {
+        params[0] = wrapConfigAndVerify(params[0]);
+      }
+      const command = getCommand({ params, assertIsValid });
+      const result = await command.execute();
+      const consumerEmittedData = {
+        data: void 0,
+        errors: void 0
+      };
+      if (result.isOk()) {
+        deepFreeze(result.value);
+        consumerEmittedData.data = result.value.data.data;
+        consumerEmittedData.subscribe = (cb) => {
+          result.value.subscribe((res) => {
+            const consumerEmittedData2 = {
+              data: void 0,
+              errors: void 0
+            };
+            if (res.isOk()) {
+              consumerEmittedData2.data = res.value.data;
+            } else {
+              if (isUserVisibleError(res.error)) {
+                consumerEmittedData2.data = res.error.data.data;
+                consumerEmittedData2.errors = res.error.data.errors;
+              } else {
+                logError(res.error);
+                consumerEmittedData2.errors = [
+                  {
+                    message: "Internal error in GraphQL adapter occurred",
+                    locations: []
+                  }
+                ];
+              }
+            }
+            cb(consumerEmittedData2);
+          });
+        };
+        if (exposeRefresh) {
+          consumerEmittedData.refresh = () => {
+            return new Promise((resolve, reject) => {
+              try {
+                result.value.refresh().then((res) => {
+                  if (res.isOk()) {
+                    resolve();
+                  } else {
+                    reject(
+                      new Error(
+                        "Internal error in GraphQL adapter occurred: Failed to refresh GraphQL data"
+                      )
+                    );
+                  }
+                });
+              } catch (error) {
+                logError(error);
+                reject(
+                  new Error(
+                    "Internal error in GraphQL adapter occurred: Failed to refresh GraphQL data"
+                  )
+                );
+              }
+            });
+          };
+        }
+      } else {
+        if (isUserVisibleError(result.error)) {
+          consumerEmittedData.data = result.error.data.data;
+          consumerEmittedData.errors = result.error.data.errors;
+        } else {
+          logError(result.error);
+          consumerEmittedData.errors = [
+            { message: "Internal error in GraphQL adapter occurred", locations: [] }
+          ];
+        }
+      }
+      return consumerEmittedData;
+    } catch (error) {
+      logError(error);
+      return {
+        data: void 0,
+        errors: [{ message: "Internal error in GraphQL adapter occurred", locations: [] }]
+      };
+    }
+  };
+}
 function buildAsyncGraphQLImperativeLegacyInvoker(getCommand) {
   const invoke = async (config, requestContext, callback) => {
+    config = wrapConfigAndVerify(config);
     const command = getCommand({ config, assertIsValid });
     try {
       const overrides = requestContextIsCachePolicy(requestContext) ? { cacheControlConfig: { type: "no-cache" } } : {};
@@ -100492,6 +100864,7 @@ function buildAsyncGraphQLImperativeLegacyInvoker(getCommand) {
     }
   };
   const subscribe = (config, requestContext, callback) => {
+    config = wrapConfigAndVerify(config);
     const command = getCommand({ config, assertIsValid });
     let unsubscribe = () => {
     };
@@ -100552,14 +100925,7 @@ function buildAsyncGraphQLImperativeLegacyInvoker(getCommand) {
 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";
 }
-function resolveAst(ast) {
-  const result = astResolver(ast);
-  if (result === void 0) {
-    throw new Error("Could not resolve AST. Did you parse the query with gql?");
-  }
-  return result;
-}
-// version: 1.382.0-73d929ea11
+// version: 1.384.0-835fd13f44
 
 class Analytics__AnalyticsBrowseRepository extends UnidentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
@@ -100624,6 +100990,7 @@ class Analytics__AnalyticsRepresentationRepository extends IdentifiableGraphQLTy
         this.namespace = "oas";
         this.typeName = "Analytics__AnalyticsRepresentation";
         this.implementedInterfaces = ["Analytics__AnalyticsRepresentationInterface"];
+        this.idField = "Id";
     }
     get fields() {
         return {
@@ -100642,9 +101009,6 @@ class Analytics__AnalyticsRepresentationRepository extends IdentifiableGraphQLTy
             Dataspaces: new BaseArrayFieldDef(new BaseObjectFieldDef(this.typeRegistry.Analytics__DataspaceRepresentation, true), true),
         };
     }
-    buildKeyParams(input) {
-        return { Id: input.data.Id };
-    }
     get cacheControl() {
         return { type: "max-age", maxAge: 60 };
     }
@@ -100715,6 +101079,7 @@ class Analytics__AnalyticsWorkspaceRepository extends IdentifiableGraphQLTypeRep
         this.namespace = "oas";
         this.typeName = "Analytics__AnalyticsWorkspace";
         this.implementedInterfaces = [];
+        this.idField = "Id";
     }
     get fields() {
         return {
@@ -100729,9 +101094,6 @@ class Analytics__AnalyticsWorkspaceRepository extends IdentifiableGraphQLTypeRep
             ApiName: new BaseScalarFieldDef(false),
         };
     }
-    buildKeyParams(input) {
-        return { Id: input.data.Id };
-    }
     get cacheControl() {
         return { type: "max-age", maxAge: 60 };
     }
@@ -100745,6 +101107,7 @@ class Analytics__DataspaceRepresentationRepository extends IdentifiableGraphQLTy
         this.namespace = "oas";
         this.typeName = "Analytics__DataspaceRepresentation";
         this.implementedInterfaces = [];
+        this.idField = "Id";
     }
     get fields() {
         return {
@@ -100755,9 +101118,6 @@ class Analytics__DataspaceRepresentationRepository extends IdentifiableGraphQLTy
             DeveloperName: new BaseScalarFieldDef(true),
         };
     }
-    buildKeyParams(input) {
-        return { Id: input.data.Id };
-    }
     get cacheControl() {
         return { type: "max-age", maxAge: 60 };
     }
@@ -101935,6 +102295,7 @@ let RecordRepresentationRepository$1 = class RecordRepresentationRepository exte
         this.namespace = "oas";
         this.typeName = "RecordRepresentation";
         this.implementedInterfaces = ["Record"];
+        this.idField = "Id";
     }
     get fields() {
         return {
@@ -101978,9 +102339,6 @@ let RecordRepresentationRepository$1 = class RecordRepresentationRepository exte
             AnyType: new BaseObjectFieldDef(this.typeRegistry.AnyType, true),
         };
     }
-    buildKeyParams(input) {
-        return { Id: input.data.Id };
-    }
     get cacheControl() {
         return { type: "max-age", maxAge: 60 };
     }
@@ -102110,6 +102468,7 @@ class Setup__EntityRepresentationRepository extends IdentifiableGraphQLTypeRepos
         this.namespace = "oas";
         this.typeName = "Setup__EntityRepresentation";
         this.implementedInterfaces = [];
+        this.idField = "Id";
     }
     get fields() {
         return {
@@ -102148,9 +102507,6 @@ class Setup__EntityRepresentationRepository extends IdentifiableGraphQLTypeRepos
             AnyType: new BaseObjectFieldDef(this.typeRegistry.AnyType, true),
         };
     }
-    buildKeyParams(input) {
-        return { Id: input.data.Id };
-    }
     get cacheControl() {
         return { type: "max-age", maxAge: 60 };
     }
@@ -102325,6 +102681,7 @@ class Setup__ListViewRowRepository extends IdentifiableGraphQLTypeRepository {
         this.namespace = "oas";
         this.typeName = "Setup__ListViewRow";
         this.implementedInterfaces = [];
+        this.idField = "id";
     }
     get fields() {
         return {
@@ -102333,9 +102690,6 @@ class Setup__ListViewRowRepository extends IdentifiableGraphQLTypeRepository {
             columns: new BaseArrayFieldDef(new BaseObjectFieldDef(this.typeRegistry.Setup__ListScalarField, true), false),
         };
     }
-    buildKeyParams(input) {
-        return { id: input.data.id };
-    }
     get cacheControl() {
         return { type: "max-age", maxAge: 60 };
     }
@@ -103371,6 +103725,61 @@ function getFieldCategoryFromData(data) {
     return data.__genericTypename || data.__typename;
 }
 
+/**
+ * Finds the typename field name from GraphQL selections, looking for __typename or aliased fields.
+ *
+ * @param input - The normalize/denormalize data input containing selections
+ * @returns The field name to use for typename lookup, or '__typename' as fallback
+ */
+function findTypenameFieldFromSelections(input) {
+    // For normalize inputs, check if selections exist and find __typename field
+    if (input && 'selections' in input && Array.isArray(input.selections)) {
+        const typenameSelection = input.selections.find((selection) => selection.kind === 'Field' && selection.name?.value === '__typename');
+        if (typenameSelection) {
+            // If there's an alias, use the alias name, otherwise use the field name
+            return typenameSelection.alias?.value || typenameSelection.name.value;
+        }
+    }
+    // Fallback to standard __typename field name
+    return '__typename';
+}
+/**
+ * Checks if the input data satisfies a fragment type condition by comparing the typename
+ * from the input data with the fragment's conditional type name.
+ *
+ * @param input - The normalize/denormalize data input containing the typename
+ * @param fragment - The fragment containing the type condition
+ * @returns Result<boolean, Error> - true if the type condition is satisfied
+ */
+function dataSatisfiesFragmentTypeCondition(input, fragment) {
+    const conditionalTypeName = fragment?.typeCondition?.name.value;
+    const typename = input?.data?.[findTypenameFieldFromSelections(input)] ||
+        input?.normalizedData?.__typename?.data;
+    if (conditionalTypeName && typename === conditionalTypeName) {
+        return ok(true);
+    }
+    return ok(false);
+}
+/**
+ * Generic implementation of satisfiesFragmentTypeCondition for repositories.
+ * Combines the base class type condition check with custom typename validation.
+ *
+ * @param superSatisfiesFragmentTypeCondition - The super class method to call first
+ * @param input - The normalize/denormalize data input
+ * @param fragment - The fragment containing the type condition
+ * @param typeName - The repository type name for error messages
+ * @returns Result<boolean, Error> - true if the fragment type condition is satisfied
+ */
+function genericSatisfiesFragmentTypeCondition(superSatisfiesFragmentTypeCondition, input, fragment, typeName) {
+    // First try the base class implementation
+    const result = superSatisfiesFragmentTypeCondition(input, fragment);
+    if (result.isErr() || result.value) {
+        return result;
+    }
+    // Then try our custom typename checking
+    return dataSatisfiesFragmentTypeCondition(input, fragment);
+}
+
 class RecordRepresentationBaseRepository extends BaseGraphQLTypeRepository {
     constructor(namespace, typeName, implementedInterfaces, fields, idField, services) {
         super();
@@ -103397,15 +103806,8 @@ class RecordRepresentationBaseRepository extends BaseGraphQLTypeRepository {
     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}`));
+    satisfiesFragmentTypeCondition(input, fragment) {
+        return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), input, fragment, this.typeName);
     }
 }
 
@@ -103414,7 +103816,7 @@ class RecordRepresentationRepository extends RecordRepresentationRepository$1 {
         super(services, typeRegistry);
         this.services = services;
         this.typeRegistry = typeRegistry;
-        this.namespace = 'oas';
+        this.namespace = 'uiapi';
         this.typeName = 'RecordRepresentation';
         this.implementedInterfaces = ['Record'];
         this._graphqlRepositoryOverride = undefined;
@@ -103566,14 +103968,7 @@ class CompoundFieldRepository extends CompoundFieldRepository$1 {
         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}`));
+        return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
     }
 }
 
@@ -103597,14 +103992,7 @@ class RecordAggregateRepository extends RecordAggregateRepository$1 {
         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}`));
+        return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
     }
 }
 
@@ -103640,7 +104028,7 @@ class SetupEntityRepresentationRepository extends UnidentifiableGraphQLTypeRepos
         super(services);
         this.services = services;
         this.typeRegistry = typeRegistry;
-        this.namespace = 'oas';
+        this.namespace = 'uiapi';
         this.typeName = 'Setup__EntityRepresentation';
         this.implementedInterfaces = [];
     }
@@ -103690,14 +104078,7 @@ class SetupEntityRepresentationRepository extends UnidentifiableGraphQLTypeRepos
         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}`));
+        return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), input, fragment, this.typeName);
     }
 }
 
@@ -103737,14 +104118,7 @@ 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}`));
+        return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
     }
 }
 
@@ -103763,7 +104137,7 @@ class SetupRepository extends IdentifiableGraphQLTypeRepository {
     constructor(services, typeRegistry) {
         super(services);
         this.typeRegistry = typeRegistry;
-        this.namespace = 'oas';
+        this.namespace = 'uiapi';
         this.typeName = 'Setup__Setup';
         this.implementedInterfaces = [];
         this.cacheControl = {
@@ -103784,14 +104158,7 @@ class SetupRepository extends IdentifiableGraphQLTypeRepository {
 
 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}`));
+        return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
     }
 }
 
@@ -103805,118 +104172,55 @@ class PolymorphicAggregateParentRelationshipRepository extends PolymorphicAggreg
 
 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}`));
+        return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
     }
 }
 
 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}`));
+        return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
     }
 }
 
 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}`));
+        return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
     }
 }
 
 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}`));
+        return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
     }
 }
 
 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}`));
+        return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
     }
 }
 
 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}`));
+        return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
     }
 }
 
 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}`));
+        return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
     }
 }
 
 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}`));
+        return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
     }
 }
 
 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}`));
+        return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
     }
 }
 
@@ -104335,6 +104639,7 @@ function buildCommandClass(baseClass) {
 
 let graphql$1;
 let graphql_imperative$1;
+let graphql_imperative_legacy;
 let useOneStoreGraphQL = false;
 const serviceRequirements = {
     instrumentCommand: {
@@ -104394,18 +104699,24 @@ getServices(serviceRequirements).then((services) => {
             this.exposeRefresh = true;
         }
         getCommand() {
-            return new graphql_ctor({ ...this.config, query: resolveAst(this.config.query) }, documentRootType, services);
+            return new graphql_ctor(this.config, documentRootType, services);
         }
     };
     const graphql_imperative_ctor = services.instrumentCommand(buildCommandClass(services.auraGraphQLNormalizedCacheControlCommand), 'graphql_imperative');
-    graphql_imperative$1 = buildAsyncGraphQLImperativeLegacyInvoker(({ config, assertIsValid }) => {
+    graphql_imperative$1 = buildAsyncGraphQLImperativeInvoker(({ params, assertIsValid }) => {
+        const config = params[0];
+        const _ = assertIsValid;
+        _(config, CONFIG_SCHEMA);
+        return new graphql_imperative_ctor(config, documentRootType, services);
+    }, true);
+    graphql_imperative_legacy = buildAsyncGraphQLImperativeLegacyInvoker(({ config, assertIsValid }) => {
         const _ = assertIsValid;
         _(config, CONFIG_SCHEMA);
-        return new graphql_imperative_ctor({ ...config, query: resolveAst(config.query) }, documentRootType, services);
+        return new graphql_imperative_ctor(config, documentRootType, services);
     });
     useOneStoreGraphQL = services.featureFlags?.get('useOneStoreGraphQL') ?? false;
     if (provisionedCallback) {
-        provisionedCallback(graphql$1, graphql_imperative$1, useOneStoreGraphQL);
+        provisionedCallback(graphql$1, graphql_imperative$1, graphql_imperative_legacy, useOneStoreGraphQL);
     }
 }, (_err) => { });
 function registerCallback(cb) {
@@ -104413,10 +104724,10 @@ function registerCallback(cb) {
         provisionedCallback = cb;
     }
     else {
-        cb(graphql$1, graphql_imperative$1, useOneStoreGraphQL);
+        cb(graphql$1, graphql_imperative$1, graphql_imperative_legacy, useOneStoreGraphQL);
     }
 }
-// version: 1.382.0-73d929ea11
+// version: 1.384.0-835fd13f44
 
 function createFragmentMap(documentNode) {
     const fragments = {};
@@ -130368,11 +130679,15 @@ function buildCachedSnapshotCachePolicy(context, storeLookup) {
     return cacheSnapshot;
 }
 
+// Wire Adapters
 let graphql;
 let graphqlBatch;
 // Imperative GET Adapters
 let graphql_imperative;
 let graphqlBatch_imperative;
+let refreshGraphQL = (data) => {
+    return refresh$3(data, 'refreshUiApi');
+};
 // Adapter Metadata
 const graphqlMetadata = { apiFamily: keyPrefix$1, name: 'graphql', ttl: 900000 };
 const graphqlBatchMetadata = { apiFamily: keyPrefix$1, name: 'graphqlBatch' };
@@ -130394,10 +130709,16 @@ withDefaultLuvio((luvio) => {
     ({ graphql, graphqlBatch, graphql_imperative, graphqlBatch_imperative } = bindExportsTo(luvio));
     // We register the callback here rather than above withDefaultLuvio because we want environments
     // that don't have onestore bootstrapped with the required services to default to the luvio versions of the adapters
-    registerCallback((oneStoreGraphql, oneStoreGraphql_imperative, useOneStoreGraphQL) => {
+    registerCallback((oneStoreGraphql, oneStoreGraphql_imperative, oneStoreGraphql_imperative_legacy, useOneStoreGraphQL) => {
         if (useOneStoreGraphQL) {
             graphql = oneStoreGraphql;
-            graphql_imperative = oneStoreGraphql_imperative;
+            graphql_imperative = oneStoreGraphql_imperative_legacy;
+            refreshGraphQL = (data) => {
+                if (typeof data?.refresh === 'function') {
+                    return data.refresh();
+                }
+                throw new Error('Component attempted to refresh a GraphQL result that is not refreshable');
+            };
         }
     });
 });
@@ -130904,14 +131225,7 @@ register$1({
     configuration: { ...configurationForGraphQLAdapters$1 },
     instrument: instrument$1,
 });
-function refreshGraphQL(data) {
-    // If OneStore data, call its refresh instead
-    if (typeof data?.refresh === 'function') {
-        return data.refresh();
-    }
-    return refresh$3(data, 'refreshUiApi');
-}
-// version: 1.382.0-73d929ea11
+// version: 1.384.0-835fd13f44
 
 // On core the unstable adapters are re-exported with different names,
 // we want to match them here.
@@ -130923,7 +131237,7 @@ var unstableLightningRelatedListApi = /*#__PURE__*/Object.freeze({
     gql: gql,
     get graphql () { return graphql; },
     get graphqlBatch () { return graphqlBatch; },
-    refreshGraphQL: refreshGraphQL,
+    get refreshGraphQL () { return refreshGraphQL; },
     get unstable_getActionOverrides_imperative () { return unstable_getActionOverrides_imperative; },
     get unstable_getFlexipageFormulaOverrides_imperative () { return unstable_getFlexipageFormulaOverrides_imperative; },
     get unstable_getGlobalActions_imperative () { return unstable_getGlobalActions_imperative; },
@@ -131063,7 +131377,7 @@ withDefaultLuvio((luvio) => {
     unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
     graphQLImperative = ldsAdapter;
 });
-// version: 1.382.0-73d929ea11
+// version: 1.384.0-835fd13f44
 
 var gqlApi = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -131862,7 +132176,7 @@ const callbacks$1 = [];
 function register(r) {
     callbacks$1.forEach((callback) => callback(r));
 }
-// version: 1.382.0-8ca71123b0
+// version: 1.384.0-cb845692ac
 
 /**
  * Copyright (c) 2022, Salesforce, Inc.,
@@ -133178,4 +133492,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.382.0-8ca71123b0
+// version: 1.384.0-cb845692ac