@salesforce/lds-worker-api 1.380.0-dev8 → 1.380.0-dev9

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

@@ -27,7 +27,7 @@
     })(SnapshotState$3 || (SnapshotState$3 = {}));
 
     const { create: create$b, entries: entries$7, freeze: freeze$7, keys: keys$b, values: values$3, assign: assign$8 } = Object;
-    const { hasOwnProperty: hasOwnProperty$5 } = Object.prototype;
+    const { hasOwnProperty: hasOwnProperty$6 } = Object.prototype;
     const { isArray: isArray$a } = Array;
     const { push: push$5, indexOf, slice: slice$2 } = Array.prototype;
     const { parse: parse$c, stringify: stringify$c } = JSON;
@@ -629,9 +629,9 @@
         readMetadataWhere(query) {
             const keys$1 = keys$b(this.metadata);
             const results = [];
-            const hasNamespaceQuery = hasOwnProperty$5.call(query, 'namespace');
-            const hasRepresentationNameQuery = hasOwnProperty$5.call(query, 'representationName');
-            const hasTtlOverrideQuery = hasOwnProperty$5.call(query, 'ttlOverride');
+            const hasNamespaceQuery = hasOwnProperty$6.call(query, 'namespace');
+            const hasRepresentationNameQuery = hasOwnProperty$6.call(query, 'representationName');
+            const hasTtlOverrideQuery = hasOwnProperty$6.call(query, 'ttlOverride');
             for (let i = 0, length = keys$1.length; i < length; i++) {
                 const key = keys$1[i];
                 const storeMetadata = this.metadata[key];
@@ -655,7 +655,7 @@
         put(recordId, record) {
             const { records, insertedIds, pendingTrimKeys, retainedIds } = this;
             const canonicalKey = this.getCanonicalRecordId(recordId);
-            if (hasOwnProperty$5.call(records, canonicalKey) === false) {
+            if (hasOwnProperty$6.call(records, canonicalKey) === false) {
                 insertedIds[canonicalKey] = true;
             }
             records[canonicalKey] = record;
@@ -1330,9 +1330,9 @@
                 return this.fallbackStringKeyInMemoryStore.readMetadataWhere(query);
             }
             const results = [];
-            const hasNamespaceQuery = hasOwnProperty$5.call(query, 'namespace');
-            const hasRepresentationNameQuery = hasOwnProperty$5.call(query, 'representationName');
-            const hasTtlOverrideQuery = hasOwnProperty$5.call(query, 'ttlOverride');
+            const hasNamespaceQuery = hasOwnProperty$6.call(query, 'namespace');
+            const hasRepresentationNameQuery = hasOwnProperty$6.call(query, 'representationName');
+            const hasTtlOverrideQuery = hasOwnProperty$6.call(query, 'ttlOverride');
             for (let i = 0, length = keys.length; i < length; i++) {
                 const key = keys[i];
                 const storeMetadata = this.metadataMap.get(key);
@@ -2171,8 +2171,8 @@
     function isNodeLink(node) {
         return (typeof node === 'object' &&
             node !== null &&
-            (hasOwnProperty$5.call(node, '__ref') ||
-                hasOwnProperty$5.call(node, 'isMissing')));
+            (hasOwnProperty$6.call(node, '__ref') ||
+                hasOwnProperty$6.call(node, 'isMissing')));
     }
     function isGraphNode$2(node) {
         return node !== null && node.type === GraphNodeType$1.Node;
@@ -2317,7 +2317,7 @@
         }
         var values = [];
         for (var _argName in argValues) {
-            if (hasOwnProperty$5.call(argValues, _argName)) {
+            if (hasOwnProperty$6.call(argValues, _argName)) {
                 var value = argValues[_argName];
                 if (value !== null || value !== undefined) {
                     values.push(_argName + ':' + stringify$c(value));
@@ -2657,7 +2657,7 @@
                         data[key] = items;
                     }
                     else {
-                        if (hasOwnProperty$5.call(visitedKeys, nextRecordId) === true) {
+                        if (hasOwnProperty$6.call(visitedKeys, nextRecordId) === true) {
                             throw new Error(`Invalid eager selection on records with circular references.`);
                         }
                         const lookupResult = this.resolveKey(nextRecordId);
@@ -3139,7 +3139,7 @@
             }
         }
         readScalar(propertyName, record, data, required) {
-            if (!hasOwnProperty$5.call(record, propertyName)) {
+            if (!hasOwnProperty$6.call(record, propertyName)) {
                 if (required !== false) {
                     this.markMissing();
                     return;
@@ -4280,7 +4280,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.380.0-dev8-c2a0c4e2de
+    // version: 1.380.0-dev9-0a2876c461
 
     // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
     function instrumentAdapter$1(createFunction, _metadata) {
@@ -5324,7 +5324,7 @@
         const { apiFamily, name } = metadata;
         return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
     }
-    // version: 1.380.0-dev8-c2a0c4e2de
+    // version: 1.380.0-dev9-0a2876c461
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -6145,7 +6145,7 @@
     const keyPrefix$3 = 'UiApi';
 
     const { assign: assign$6, create: create$8, freeze: freeze$5, isFrozen: isFrozen$3, keys: keys$9 } = Object;
-    const { hasOwnProperty: hasOwnProperty$4 } = Object.prototype;
+    const { hasOwnProperty: hasOwnProperty$5 } = Object.prototype;
     const { split: split$1, endsWith: endsWith$1 } = String.prototype;
     const { isArray: isArray$8 } = Array;
     const { concat: concat$3, filter: filter$3, includes: includes$3, push: push$4, reduce: reduce$3 } = Array.prototype;
@@ -9358,7 +9358,7 @@
         }
         // Stop the traversal if the key has already been visited, since the fields for this record
         // have already been gathered at this point.
-        if (hasOwnProperty$4.call(visitedRecordIds, recordId)) {
+        if (hasOwnProperty$5.call(visitedRecordIds, recordId)) {
             return;
         }
         // The visitedRecordIds object passed to the spanning record is a copy of the original
@@ -10164,20 +10164,20 @@
         return [...fieldsArray, ...optionalFieldsArray];
     }
     function getRecordIdsFromUrlParams$1(urlParams) {
-        if (hasOwnProperty$4.call(urlParams, 'recordId')) {
+        if (hasOwnProperty$5.call(urlParams, 'recordId')) {
             return [urlParams.recordId];
         }
-        else if (hasOwnProperty$4.call(urlParams, 'recordIds')) {
+        else if (hasOwnProperty$5.call(urlParams, 'recordIds')) {
             return urlParams.recordIds;
         }
         return [];
     }
     function isSingleBatchRecordRequest$1(urlParams) {
-        return (hasOwnProperty$4.call(urlParams, 'recordIds') &&
+        return (hasOwnProperty$5.call(urlParams, 'recordIds') &&
             urlParams.recordIds.length === 1);
     }
     function isSingleRecordRequest$1(urlParams) {
-        return hasOwnProperty$4.call(urlParams, 'recordId');
+        return hasOwnProperty$5.call(urlParams, 'recordId');
     }
     function isRestrictedPathCondition$1(existingPath, path) {
         // should not dedupe getRecordUi and getRecord as both of their representation is different
@@ -15127,7 +15127,7 @@
         // W-12697744 - Return an empty layoutMap if the entity does not have a layout.
         // Temp fix until we can mimic the server behavior for non-layoutable entities.
         let layoutMap = {};
-        if (hasOwnProperty$4.call(layouts, apiName)) {
+        if (hasOwnProperty$5.call(layouts, apiName)) {
             layoutMap = layouts[apiName][recordTypeId] || {};
         }
         return {
@@ -34160,7 +34160,7 @@
         throttle(60, 60000, setupNotifyAllListRecordUpdateAvailable(luvio));
         throttle(60, 60000, setupNotifyAllListInfoSummaryUpdateAvailable(luvio));
     });
-    // version: 1.380.0-dev8-60930b5790
+    // version: 1.380.0-dev9-476a6580cf
 
     function requestIdleDetectedCallback(_callback) { }
     function declareNotifierTaskSingle(_name) {
@@ -43130,7 +43130,7 @@
           return "continue";
         }
 
-        if (!hasOwnProperty$3(inputs, varName)) {
+        if (!hasOwnProperty$4(inputs, varName)) {
           if (varDefNode.defaultValue) {
             coercedValues[varName] = valueFromAST(varDefNode.defaultValue, varType);
           } else if (isNonNullType(varType)) {
@@ -43214,7 +43214,7 @@
         if (valueNode.kind === Kind$3.VARIABLE) {
           var variableName = valueNode.name.value;
 
-          if (variableValues == null || !hasOwnProperty$3(variableValues, variableName)) {
+          if (variableValues == null || !hasOwnProperty$4(variableValues, variableName)) {
             if (argDef.defaultValue !== undefined) {
               coercedValues[name] = argDef.defaultValue;
             } else if (isNonNullType(argType)) {
@@ -43267,7 +43267,7 @@
       }
     }
 
-    function hasOwnProperty$3(obj, prop) {
+    function hasOwnProperty$4(obj, prop) {
       return Object.prototype.hasOwnProperty.call(obj, prop);
     }
 
@@ -45785,7 +45785,7 @@
      * For full license text, see the LICENSE.txt file
      */
     const { create: create$7, freeze: freeze$4, keys: keys$8, entries: entries$6 } = Object;
-    const { hasOwnProperty: hasOwnProperty$2 } = Object.prototype;
+    const { hasOwnProperty: hasOwnProperty$3 } = Object.prototype;
     const { isArray: isArray$7 } = Array;
     const { stringify: stringify$9, parse: parse$9 } = JSON;
     let Ok$4 = class Ok {
@@ -49294,7 +49294,7 @@
     const keyPrefix$2 = 'UiApi';
 
     const { assign: assign$2, create: create$3$1, entries: entries$3, freeze: freeze$1$1, isFrozen: isFrozen$2, keys: keys$3$1, values: values$1 } = Object;
-    const { hasOwnProperty: hasOwnProperty$1 } = Object.prototype;
+    const { hasOwnProperty: hasOwnProperty$2 } = Object.prototype;
     const { split, endsWith } = String.prototype;
     const { from: from$1, isArray: isArray$3$1 } = Array;
     const { concat: concat$2, filter: filter$2, includes: includes$2, push: push$1$1, reduce: reduce$2, shift, slice: slice$1 } = Array.prototype;
@@ -51416,20 +51416,20 @@
         return [...fieldsArray, ...optionalFieldsArray];
     }
     function getRecordIdsFromUrlParams(urlParams) {
-        if (hasOwnProperty$1.call(urlParams, 'recordId')) {
+        if (hasOwnProperty$2.call(urlParams, 'recordId')) {
             return [urlParams.recordId];
         }
-        else if (hasOwnProperty$1.call(urlParams, 'recordIds')) {
+        else if (hasOwnProperty$2.call(urlParams, 'recordIds')) {
             return urlParams.recordIds;
         }
         return [];
     }
     function isSingleBatchRecordRequest(urlParams) {
-        return (hasOwnProperty$1.call(urlParams, 'recordIds') &&
+        return (hasOwnProperty$2.call(urlParams, 'recordIds') &&
             urlParams.recordIds.length === 1);
     }
     function isSingleRecordRequest(urlParams) {
-        return hasOwnProperty$1.call(urlParams, 'recordId');
+        return hasOwnProperty$2.call(urlParams, 'recordId');
     }
     function isRestrictedPathCondition(existingPath, path) {
         // should not dedupe getRecordUi and getRecord as both of their representation is different
@@ -55952,7 +55952,7 @@
         // W-12697744 - Return an empty layoutMap if the entity does not have a layout.
         // Temp fix until we can mimic the server behavior for non-layoutable entities.
         let layoutMap = {};
-        if (hasOwnProperty$1.call(layouts, apiName)) {
+        if (hasOwnProperty$2.call(layouts, apiName)) {
             layoutMap = layouts[apiName][recordTypeId] || {};
         }
         return {
@@ -96000,7 +96000,7 @@
             },
         };
     }
-    // version: 1.380.0-dev8-60930b5790
+    // version: 1.380.0-dev9-476a6580cf
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -96026,7 +96026,7 @@
             },
         };
     }
-    // version: 1.380.0-dev8-60930b5790
+    // version: 1.380.0-dev9-476a6580cf
 
     /*!
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -98174,7 +98174,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$2,
     });
-    // version: 1.380.0-dev8-c2a0c4e2de
+    // version: 1.380.0-dev9-0a2876c461
 
     const { create: create$3, keys: keys$3 } = Object;
     const { stringify: stringify$1, parse } = JSON;
@@ -99063,7 +99063,7 @@
     function deepMerge$2(target, ...sources) {
       for (const source of sources) {
         for (const key in source) {
-          if (hasOwnProperty$2.call(source, key)) {
+          if (hasOwnProperty$3.call(source, key)) {
             const targetValue = target[key];
             const sourceValue = source[key];
             if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
@@ -100828,6 +100828,94 @@
         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 {
+            const failure = result.error.failure;
+            if (isUserVisibleError(failure)) {
+              consumerEmittedData.data = failure.data.data;
+              consumerEmittedData.errors = failure.data.errors;
+            } else {
+              logError(failure);
+              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);
@@ -100933,7 +101021,7 @@
       }
       callback(consumerEmittedData);
     }
-    // version: 1.380.0-dev8-60930b5790
+    // version: 1.380.0-dev9-476a6580cf
 
     class Analytics__AnalyticsBrowseRepository extends UnidentifiableGraphQLTypeRepository {
         constructor(services, typeRegistry) {
@@ -103590,6 +103678,7 @@
      * All rights reserved.
      * For full license text, see the LICENSE.txt file
      */
+    const { hasOwnProperty: hasOwnProperty$1 } = Object.prototype;
     class Ok {
       constructor(value) {
         this.value = value;
@@ -104015,18 +104104,133 @@
         }
     }
 
-    // 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(input.normalizedData);
-        },
-        write: (_cache, input) => {
-            return ok(input.data);
-        },
-        buildFieldKey: (selection, variables) => buildFieldKey(selection.name.value, selection.arguments, variables),
-        augmentSelections: (input) => input,
-    };
+    class BlobObjectRepository extends UnidentifiableGraphQLTypeRepository {
+        constructor() {
+            super(...arguments);
+            this.namespace = 'uiapi';
+            this.typeName = 'Blob';
+            this.fields = {};
+            this.implementedInterfaces = [];
+        }
+        normalizeFragment(_cache, _input, _fragment, errorCollector) {
+            errorCollector.push({
+                type: 'unknown',
+                error: new Error('Fragments are not supported for Blob fields'),
+            });
+            return {};
+        }
+        denormalizeFragment(_cache, _input, _fragment, errorCollector) {
+            errorCollector.push({
+                type: 'unknown',
+                error: new Error('Fragments are not supported for Blob fields'),
+            });
+            return {};
+        }
+        getFieldDef(_input, _selection) {
+            return new BlobFieldDef({});
+        }
+    }
+    class BlobFieldDef {
+        constructor(services) {
+            this.objectRepository = new BlobObjectRepository(services);
+        }
+        read(cache, input) {
+            const errors = [];
+            if (input.normalizedData.type === 'array') {
+                const data = input.normalizedData.data.map((item) => {
+                    const result = this.read(cache, { ...input, normalizedData: item });
+                    if (result.isErr()) {
+                        errors.push(...result.error);
+                        return undefined;
+                    }
+                    return result.value;
+                });
+                if (errors.length > 0) {
+                    return err(errors);
+                }
+                return ok(data);
+            }
+            else if (input.normalizedData.type === 'object') {
+                const selections = input.selection.selectionSet?.selections;
+                if (!selections) {
+                    return err([
+                        {
+                            type: 'unknown',
+                            error: new Error('Object data must have a selection set'),
+                        },
+                    ]);
+                }
+                const result = this.objectRepository.read(cache, {
+                    ...input,
+                    normalizedData: input.normalizedData.data,
+                    selections,
+                    request: input.request,
+                });
+                if (result.isErr()) {
+                    return err(result.error);
+                }
+                return ok(result.value);
+            }
+            else {
+                return ok(input.normalizedData.data);
+            }
+        }
+        write(cache, input) {
+            if (Array.isArray(input.data)) {
+                const errors = [];
+                const result = {
+                    type: 'array',
+                    data: input.data.map((item) => {
+                        const result = this.write(cache, { ...input, data: item });
+                        if (result.isErr()) {
+                            errors.push(...result.error);
+                            return undefined;
+                        }
+                        return result.value;
+                    }),
+                };
+                if (errors.length > 0) {
+                    return err(errors);
+                }
+                return ok(result);
+            }
+            else if (typeof input.data === 'object' && input.data !== null) {
+                const selections = input.selection.selectionSet?.selections;
+                if (!selections) {
+                    return err([
+                        {
+                            type: 'unknown',
+                            error: new Error('Object data must have a selection set'),
+                        },
+                    ]);
+                }
+                const result = this.objectRepository.write(cache, {
+                    ...input,
+                    selections,
+                    request: input.request,
+                });
+                if (result.isErr()) {
+                    return err(result.error);
+                }
+                return ok({
+                    type: 'object',
+                    data: result.value,
+                });
+            }
+            else {
+                return ok({
+                    type: 'scalar',
+                    data: input.data,
+                });
+            }
+        }
+        buildFieldKey(selection, variables) {
+            return buildFieldKey(selection.name.value, selection.arguments, variables);
+        }
+        augmentSelections(input) {
+            return input;
+        }
+    }
 
     // The generated repository is identifiable, since setup data isn't cached,
     // there's no need for an identifiable repository
@@ -104082,7 +104286,7 @@
                 return super.getFieldDef(input, selection);
             }
             // We should make this smarter, storing and returning blobs isn't great since it could, and likely will, include unrequested field data
-            return blobTypeDef;
+            return new BlobFieldDef(this.services);
         }
         satisfiesFragmentTypeCondition(input, fragment) {
             return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), input, fragment, this.typeName);
@@ -104122,7 +104326,7 @@
             if (staticFields.includes(selection.name.value)) {
                 return super.getFieldDef(input, selection);
             }
-            return blobTypeDef;
+            return new BlobFieldDef(this.services);
         }
         satisfiesFragmentTypeCondition(_input, fragment) {
             return genericSatisfiesFragmentTypeCondition(super.satisfiesFragmentTypeCondition.bind(this), _input, fragment, this.typeName);
@@ -104644,8 +104848,56 @@
         };
     }
 
+    function validateNonQueryGraphQLConfig(config) {
+        if (config !== null && typeof config === 'object') {
+            if (hasOwnProperty$1.call(config, 'operationName') &&
+                config.operationName === undefined) {
+                return err('operationName is undefined');
+            }
+            if (hasOwnProperty$1.call(config, 'variables') &&
+                config.variables === undefined) {
+                return err('variables is undefined');
+            }
+            return ok(config);
+        }
+        return err('config is not an object');
+    }
+
+    class GraphQLCommandWireAdapterConstructorV1Import extends GraphQLCommandWireAdapterConstructor {
+        update(config, _context) {
+            const validatedConfig = validateNonQueryGraphQLConfig(config);
+            if (validatedConfig.isErr()) {
+                // config is incomplete, delay execution
+                return;
+            }
+            super.update(validatedConfig.value, _context);
+        }
+    }
+
+    function buildAsyncGraphQLImperativeLegacyInvokerV1Import(getCommand) {
+        const { invoke: invokeOriginal, subscribe: subscribeOriginal } = buildAsyncGraphQLImperativeLegacyInvoker(getCommand);
+        const invoke = async (config, requestContext, callback) => {
+            const validatedConfig = validateNonQueryGraphQLConfig(config);
+            if (validatedConfig.isErr()) {
+                throw new Error(`Invalid configuration passed to GraphQL: ${validatedConfig.error}`);
+            }
+            return invokeOriginal(validatedConfig.value, requestContext, callback);
+        };
+        const subscribe = (config, requestContext, callback) => {
+            const validatedConfig = validateNonQueryGraphQLConfig(config);
+            if (validatedConfig.isErr()) {
+                throw new Error(`Invalid configuration passed to GraphQL: ${validatedConfig.error}`);
+            }
+            return subscribeOriginal(validatedConfig.value, requestContext, callback);
+        };
+        return { invoke, subscribe };
+    }
+
     let graphql$1;
+    let graphql_v1_import;
     let graphql_imperative$1;
+    let graphql_imperative_legacy;
+    let graphql_imperative_legacy_v1_import;
     let useOneStoreGraphQL = false;
     const serviceRequirements = {
         instrumentCommand: {
@@ -104708,15 +104960,37 @@
                 return new graphql_ctor(this.config, documentRootType, services);
             }
         };
+        graphql_v1_import = class extends GraphQLCommandWireAdapterConstructorV1Import {
+            constructor() {
+                super(...arguments);
+                this.configSchema = CONFIG_SCHEMA;
+                this.exposeRefresh = true;
+            }
+            getCommand() {
+                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, documentRootType, services);
         });
+        graphql_imperative_legacy_v1_import =
+            buildAsyncGraphQLImperativeLegacyInvokerV1Import(({ config, assertIsValid }) => {
+                const _ = assertIsValid;
+                _(config, CONFIG_SCHEMA);
+                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) {
@@ -104724,10 +104998,10 @@
             provisionedCallback = cb;
         }
         else {
-            cb(graphql$1, graphql_imperative$1, useOneStoreGraphQL);
+            cb(graphql_v1_import, graphql_imperative$1, graphql_imperative_legacy_v1_import, useOneStoreGraphQL);
         }
     }
-    // version: 1.380.0-dev8-60930b5790
+    // version: 1.380.0-dev9-476a6580cf
 
     function createFragmentMap(documentNode) {
         const fragments = {};
@@ -130843,6 +131117,7 @@
         return cacheSnapshot;
     }
 
+    // Wire Adapters
     let graphql;
     let graphqlBatch;
     // Imperative GET Adapters
@@ -130869,10 +131144,10 @@
         ({ 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;
             }
         });
     });
@@ -131386,7 +131661,7 @@
         }
         return refresh$3(data, 'refreshUiApi');
     }
-    // version: 1.380.0-dev8-60930b5790
+    // version: 1.380.0-dev9-476a6580cf
 
     // On core the unstable adapters are re-exported with different names,
     // we want to match them here.
@@ -131538,7 +131813,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.380.0-dev8-60930b5790
+    // version: 1.380.0-dev9-476a6580cf
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -132337,7 +132612,7 @@
     function register(r) {
         callbacks$1.forEach((callback) => callback(r));
     }
-    // version: 1.380.0-dev8-c2a0c4e2de
+    // version: 1.380.0-dev9-0a2876c461
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -133674,4 +133949,4 @@
     exports.subscribeToAdapter = subscribeToAdapter;
 
 }));
-// version: 1.380.0-dev8-c2a0c4e2de
+// version: 1.380.0-dev9-0a2876c461