@salesforce/lds-worker-api 1.125.0 → 1.127.0

package/dist/sfdc/es/ldsWorkerApi.js

@@ -38,643 +38,653 @@ export { registerReportObserver } from 'native/ldsRuntimeMobile';
 import { HttpStatusCode } from 'force/luvioEngine';
 import { withDefaultLuvio } from 'native/ldsEngineMobile';
 
-const { create, keys } = Object;
-const { stringify, parse } = JSON;
+const { create, keys } = Object;
+const { stringify, parse } = JSON;
 const { isArray } = Array;
 
-const IMPERATIVE_ADAPTER_SUFFIX = '_imperative';
-const UNSTABLE_ADAPTER_PREFIX = 'unstable_';
-function extractWireAdapterName(adapterName) {
-    const parts = adapterName.split(UNSTABLE_ADAPTER_PREFIX);
-    if (parts.length > 1) {
-        return parts[1].substr(0, parts[1].indexOf(IMPERATIVE_ADAPTER_SUFFIX));
-    }
-    return adapterName.substr(0, adapterName.indexOf(IMPERATIVE_ADAPTER_SUFFIX));
-}
-let lazyDMLAdapterMap = undefined;
-let lazyImperativeAdapterMap = undefined;
-// this function builds the adapter maps lazily
-function getAdapterMaps() {
-    if (lazyDMLAdapterMap === undefined || lazyImperativeAdapterMap === undefined) {
-        const map = Object.assign({
-            // We should eventually move all adapter names into this explicit list,
-            // this is our API contract to native callers and should be explicit
-            ['createContentDocumentAndVersion']: createContentDocumentAndVersion,
-            ['createContentVersion']: createContentVersion,
-        }, gqlApi, lightningAppsApi, lightningLayoutApi, lightningListApi, lightningLookupsApi, lightningObjectApi, lightningRecordActionsApi, lightningRecordApi, lightningRecordAvatarApi, lightningRelatedListApi, lightningGraphQLApi, unstableLightningAppsApi, unstableLightningLayoutApi, unstableLightningListApi, unstableLightningLookupsApi, unstableLightningObjectApi, unstableLightningRecordActionsApi, unstableLightningRecordApi, unstableLightningRecordAvatarApi, unstableLightningRelatedListApi);
-        const imperativeAdapterNames = keys(map).filter((name) => name.endsWith(IMPERATIVE_ADAPTER_SUFFIX));
-        const imperativeMap = {};
-        for (const adapterName of imperativeAdapterNames) {
-            const adapter = map[adapterName];
-            imperativeMap[adapterName] = adapter;
-            delete map[adapterName];
-            // remove the corresponding wire adapter from the adapter map
-            const wireAdapterName = extractWireAdapterName(adapterName);
-            delete map[wireAdapterName];
-        }
-        lazyDMLAdapterMap = map;
-        lazyImperativeAdapterMap = imperativeMap;
-    }
-    return { dmlAdapterMap: lazyDMLAdapterMap, imperativeAdapterMap: lazyImperativeAdapterMap };
-}
-function getDMLAdapterFromName(name) {
-    const { dmlAdapterMap } = getAdapterMaps();
-    return dmlAdapterMap[name];
-}
-function getImperativeAdapterFromName(name) {
-    const { imperativeAdapterMap } = getAdapterMaps();
-    return imperativeAdapterMap[name];
-}
-function getImperativeAdapterNames() {
-    const { imperativeAdapterMap } = getAdapterMaps();
-    return keys(imperativeAdapterMap);
+const IMPERATIVE_ADAPTER_SUFFIX = '_imperative';
+const UNSTABLE_ADAPTER_PREFIX = 'unstable_';
+function extractWireAdapterName(adapterName) {
+    const parts = adapterName.split(UNSTABLE_ADAPTER_PREFIX);
+    if (parts.length > 1) {
+        return parts[1].substr(0, parts[1].indexOf(IMPERATIVE_ADAPTER_SUFFIX));
+    }
+    return adapterName.substr(0, adapterName.indexOf(IMPERATIVE_ADAPTER_SUFFIX));
+}
+let lazyDMLAdapterMap = undefined;
+let lazyImperativeAdapterMap = undefined;
+// this function builds the adapter maps lazily
+function getAdapterMaps() {
+    if (lazyDMLAdapterMap === undefined || lazyImperativeAdapterMap === undefined) {
+        const map = Object.assign({
+            // We should eventually move all adapter names into this explicit list,
+            // this is our API contract to native callers and should be explicit
+            ['createContentDocumentAndVersion']: createContentDocumentAndVersion,
+            ['createContentVersion']: createContentVersion,
+        }, gqlApi, lightningAppsApi, lightningLayoutApi, lightningListApi, lightningLookupsApi, lightningObjectApi, lightningRecordActionsApi, lightningRecordApi, lightningRecordAvatarApi, lightningRelatedListApi, lightningGraphQLApi, unstableLightningAppsApi, unstableLightningLayoutApi, unstableLightningListApi, unstableLightningLookupsApi, unstableLightningObjectApi, unstableLightningRecordActionsApi, unstableLightningRecordApi, unstableLightningRecordAvatarApi, unstableLightningRelatedListApi);
+        const imperativeAdapterNames = keys(map).filter((name) => name.endsWith(IMPERATIVE_ADAPTER_SUFFIX));
+        const imperativeMap = {};
+        for (const adapterName of imperativeAdapterNames) {
+            const adapter = map[adapterName];
+            imperativeMap[adapterName] = adapter;
+            delete map[adapterName];
+            // remove the corresponding wire adapter from the adapter map
+            const wireAdapterName = extractWireAdapterName(adapterName);
+            delete map[wireAdapterName];
+        }
+        lazyDMLAdapterMap = map;
+        lazyImperativeAdapterMap = imperativeMap;
+    }
+    return { dmlAdapterMap: lazyDMLAdapterMap, imperativeAdapterMap: lazyImperativeAdapterMap };
+}
+function getDMLAdapterFromName(name) {
+    const { dmlAdapterMap } = getAdapterMaps();
+    return dmlAdapterMap[name];
+}
+function getImperativeAdapterFromName(name) {
+    const { imperativeAdapterMap } = getAdapterMaps();
+    return imperativeAdapterMap[name];
+}
+function getImperativeAdapterNames() {
+    const { imperativeAdapterMap } = getAdapterMaps();
+    return keys(imperativeAdapterMap);
 }
 
 const { draftManager, draftQueue } = getRuntime();
 
-const NATIVE_ERROR_CODE = 'NATIVE_ERROR';
-const NON_MUTATING_ADAPTER_MESSAGE = 'adapterId must be a mutating adapter';
-const NO_DRAFT_CREATED_MESSAGE = 'the adapter did not generate a draft';
-const DRAFT_DOESNT_EXIST_MESSAGE = 'the specified draft does not exist';
-/**
- * Error objects don't serialize well over the js-native wire, so our class turns
- * an Error into an object that serializes real nice
- */
-class NativeNetworkAdapterErrorResponse {
-    constructor(error) {
-        this.errorType = 'networkAdapterError';
-        this.message = error.message;
-        this.name = error.name;
-    }
-}
-class NativeFetchResponse {
-    constructor(status, body) {
-        this.headers = {};
-        this.status = status;
-        this.body = body;
-    }
-    get statusText() {
-        const { status } = this;
-        switch (status) {
-            case HttpStatusCode.Ok:
-                return 'OK';
-            case HttpStatusCode.Created:
-                return 'Created';
-            case HttpStatusCode.NoContent:
-                return 'No Content';
-            case HttpStatusCode.BadRequest:
-                return 'Bad Request';
-            case HttpStatusCode.ServerError:
-                return 'Server Error';
-            default:
-                return `Unexpected HTTP Status Code: ${status}`;
-        }
-    }
-    get ok() {
-        return this.status >= 200 && this.status < 300;
-    }
-}
-class NativeFetchErrorResponse extends NativeFetchResponse {
-    constructor() {
-        super(...arguments);
-        this.errorType = 'fetchResponse';
-    }
-}
-function createNativeFetchErrorResponse(message) {
-    return new NativeFetchErrorResponse(HttpStatusCode.BadRequest, {
-        errorCode: NATIVE_ERROR_CODE,
-        message: message,
-    });
-}
-/**
- * This function takes an unknown error and normalizes it to an Error object
- */
-function normalizeError(error) {
-    if (typeof error === 'object' && error instanceof Error) {
-        return error;
-    }
-    else if (typeof error === 'string') {
-        return new Error(error);
-    }
-    return new Error(stringify(error));
+const NATIVE_ERROR_CODE = 'NATIVE_ERROR';
+const NON_MUTATING_ADAPTER_MESSAGE = 'adapterId must be a mutating adapter';
+const NO_DRAFT_CREATED_MESSAGE = 'the adapter did not generate a draft';
+const DRAFT_DOESNT_EXIST_MESSAGE = 'the specified draft does not exist';
+/**
+ * Error objects don't serialize well over the js-native wire, so our class turns
+ * an Error into an object that serializes real nice
+ */
+class NativeNetworkAdapterErrorResponse {
+    constructor(error) {
+        this.errorType = 'networkAdapterError';
+        this.message = error.message;
+        this.name = error.name;
+    }
+}
+class NativeFetchResponse {
+    constructor(status, body) {
+        this.headers = {};
+        this.status = status;
+        this.body = body;
+    }
+    get statusText() {
+        const { status } = this;
+        switch (status) {
+            case HttpStatusCode.Ok:
+                return 'OK';
+            case HttpStatusCode.Created:
+                return 'Created';
+            case HttpStatusCode.NoContent:
+                return 'No Content';
+            case HttpStatusCode.BadRequest:
+                return 'Bad Request';
+            case HttpStatusCode.ServerError:
+                return 'Server Error';
+            default:
+                return `Unexpected HTTP Status Code: ${status}`;
+        }
+    }
+    get ok() {
+        return this.status >= 200 && this.status < 300;
+    }
+}
+class NativeFetchErrorResponse extends NativeFetchResponse {
+    constructor() {
+        super(...arguments);
+        this.errorType = 'fetchResponse';
+    }
+}
+function createNativeFetchErrorResponse(message) {
+    return new NativeFetchErrorResponse(HttpStatusCode.BadRequest, {
+        errorCode: NATIVE_ERROR_CODE,
+        message: message,
+    });
+}
+/**
+ * This function takes an unknown error and normalizes it to an Error object
+ */
+function normalizeError(error) {
+    if (typeof error === 'object' && error instanceof Error) {
+        return error;
+    }
+    else if (typeof error === 'string') {
+        return new Error(error);
+    }
+    return new Error(stringify(error));
 }
 
-/**
- * Coerces a cache policy passed in from native to a luvio cache policy
- * @param nativeCachePolicy The cache policy passed in from native
- * @returns A coerced luvio cache policy
- */
-function buildCachePolicy(nativeCachePolicy) {
-    if (nativeCachePolicy === undefined) {
-        return undefined;
-    }
-    // currently the types match exactly, if we ever decide to deviate then we should coerce here
-    return nativeCachePolicy;
-}
-/**
- * Coerces a request context passed in from native to a luvio request context
- * @param nativeRequestContext request context passed in from native
- * @returns Coerced luvio request context
- */
-function buildAdapterRequestContext(nativeRequestContext) {
-    if (nativeRequestContext === undefined) {
-        return undefined;
-    }
-    const { cachePolicy, priority, observabilityContext, luvioEventObserver } = nativeRequestContext;
-    const requestContext = {
-        cachePolicy: buildCachePolicy(cachePolicy),
-        priority,
-    };
-    if (observabilityContext !== undefined) {
-        requestContext.requestCorrelator = {
-            observabilityContext,
-        };
-    }
-    if (luvioEventObserver !== undefined) {
-        requestContext.eventObservers = [luvioEventObserver];
-    }
-    return requestContext;
-}
-function buildInvalidConfigError(error) {
-    return {
-        data: undefined,
-        error: {
-            ok: false,
-            status: 400,
-            statusText: 'INVALID_CONFIG',
-            body: error,
-            headers: {},
-            errorType: 'fetchResponse',
-        },
-    };
-}
-function buildNativeCallbackValue(adapterCallbackValue) {
-    const { error } = adapterCallbackValue;
-    // Luvio NetworkAdapterError objects (which are just Error objects) must be
-    // turned into NativeNetworkAdapterErrorResponse because it serializes well
-    if (error !== undefined && error.errorType === 'networkAdapterError') {
-        return {
-            data: undefined,
-            error: new NativeNetworkAdapterErrorResponse(error),
-        };
-    }
-    // any other callback value does not need coercion, just retype
-    return adapterCallbackValue;
-}
-/**
- *
- * @param adapterId
- * @returns imperative adapter key
- */
-function imperativeAdapterKeyBuilder(adapterId) {
-    if (adapterId.startsWith(UNSTABLE_ADAPTER_PREFIX)) {
-        return `${adapterId}${IMPERATIVE_ADAPTER_SUFFIX}`;
-    }
-    return `${UNSTABLE_ADAPTER_PREFIX}${adapterId}${IMPERATIVE_ADAPTER_SUFFIX}`;
-}
-/**
- * Executes the adapter with the given adapterId and config.  Will call onSnapshot
- * callback with data or error.  Returns an unsubscribe function that should
- * be called to stop receiving updated snapshots.
- *
- * This function throws an error if the given adapterId cannot be found or is not
- * a GET wire adapter.  It will also throw if it fails to parse the config string.
- */
-function subscribeToAdapter(adapterId, config, onSnapshot, nativeAdapterRequestContext) {
-    const imperativeAdapterIdentifier = imperativeAdapterKeyBuilder(adapterId);
-    const imperativeAdapter = getImperativeAdapterFromName(imperativeAdapterIdentifier);
-    const onResponseDelegate = (value) => {
-        onSnapshot(buildNativeCallbackValue(value));
-    };
-    if (imperativeAdapter === undefined) {
-        // This check is here for legacy purpose
-        // So the consumers still get the same errors
-        if (getDMLAdapterFromName(adapterId) === undefined) {
-            throw Error(`adapter ${adapterId} not recognized`);
-        }
-        throw Error(`${adapterId} is not a GET wire adapter.`);
-    }
-    const configObject = parse(config);
-    // Check if it's graphQl adapter
-    // Parse the query in that case
-    const isGql = isGqlAdapter(imperativeAdapterIdentifier);
-    if (isGql) {
-        try {
-            // gql config needs gql query string turned into AST object
-            configObject.query = parseAndVisit(configObject.query);
-        }
-        catch (err) {
-            const parseError = normalizeError(err);
-            reportGraphqlQueryParseError(parseError);
-            // call the callback with error
-            onResponseDelegate({
-                data: undefined,
-                error: createNativeFetchErrorResponse(parseError.message),
-            });
-            return () => { };
-        }
-    }
-    if (imperativeAdapterIdentifier.includes('graphql')) {
-        try {
-            //we need to use the gql literal to convert into a document node
-            //in order to get through the gql imperative adapter
+/**
+ * Coerces a cache policy passed in from native to a luvio cache policy
+ * @param nativeCachePolicy The cache policy passed in from native
+ * @returns A coerced luvio cache policy
+ */
+function buildCachePolicy(nativeCachePolicy) {
+    if (nativeCachePolicy === undefined) {
+        return undefined;
+    }
+    // currently the types match exactly, if we ever decide to deviate then we should coerce here
+    return nativeCachePolicy;
+}
+/**
+ * Coerces a request context passed in from native to a luvio request context
+ * @param nativeRequestContext request context passed in from native
+ * @returns Coerced luvio request context
+ */
+function buildAdapterRequestContext(nativeRequestContext) {
+    if (nativeRequestContext === undefined) {
+        return undefined;
+    }
+    const { cachePolicy, priority, observabilityContext, luvioEventObserver } = nativeRequestContext;
+    const requestContext = {
+        cachePolicy: buildCachePolicy(cachePolicy),
+        priority,
+    };
+    if (observabilityContext !== undefined) {
+        requestContext.requestCorrelator = {
+            observabilityContext,
+        };
+    }
+    if (luvioEventObserver !== undefined) {
+        requestContext.eventObservers = [luvioEventObserver];
+    }
+    return requestContext;
+}
+function buildInvalidConfigError(error) {
+    return {
+        data: undefined,
+        error: {
+            ok: false,
+            status: 400,
+            statusText: 'INVALID_CONFIG',
+            body: error,
+            headers: {},
+            errorType: 'fetchResponse',
+        },
+    };
+}
+function buildNativeCallbackValue(adapterCallbackValue) {
+    const { error } = adapterCallbackValue;
+    // Luvio NetworkAdapterError objects (which are just Error objects) must be
+    // turned into NativeNetworkAdapterErrorResponse because it serializes well
+    if (error !== undefined && error.errorType === 'networkAdapterError') {
+        return {
+            data: undefined,
+            error: new NativeNetworkAdapterErrorResponse(error),
+        };
+    }
+    // any other callback value does not need coercion, just retype
+    return adapterCallbackValue;
+}
+/**
+ *
+ * @param adapterId
+ * @returns imperative adapter key
+ */
+function imperativeAdapterKeyBuilder(adapterId) {
+    if (adapterId.startsWith(UNSTABLE_ADAPTER_PREFIX)) {
+        return `${adapterId}${IMPERATIVE_ADAPTER_SUFFIX}`;
+    }
+    return `${UNSTABLE_ADAPTER_PREFIX}${adapterId}${IMPERATIVE_ADAPTER_SUFFIX}`;
+}
+/**
+ * Executes the adapter with the given adapterId and config.  Will call onSnapshot
+ * callback with data or error.  Returns an unsubscribe function that should
+ * be called to stop receiving updated snapshots.
+ *
+ * This function throws an error if the given adapterId cannot be found or is not
+ * a GET wire adapter.  It will also throw if it fails to parse the config string.
+ */
+function subscribeToAdapter(adapterId, config, onSnapshot, nativeAdapterRequestContext) {
+    const imperativeAdapterIdentifier = imperativeAdapterKeyBuilder(adapterId);
+    const imperativeAdapter = getImperativeAdapterFromName(imperativeAdapterIdentifier);
+    const onResponseDelegate = (value) => {
+        onSnapshot(buildNativeCallbackValue(value));
+    };
+    if (imperativeAdapter === undefined) {
+        // This check is here for legacy purpose
+        // So the consumers still get the same errors
+        if (getDMLAdapterFromName(adapterId) === undefined) {
+            throw Error(`adapter ${adapterId} not recognized`);
+        }
+        throw Error(`${adapterId} is not a GET wire adapter.`);
+    }
+    const configObject = parse(config);
+    // Check if it's graphQl adapter
+    // Parse the query in that case
+    const isGql = isGqlAdapter(imperativeAdapterIdentifier);
+    if (isGql) {
+        try {
+            // gql config needs gql query string turned into AST object
+            configObject.query = parseAndVisit(configObject.query);
+        }
+        catch (err) {
+            const parseError = normalizeError(err);
+            reportGraphqlQueryParseError(parseError);
+            // call the callback with error
+            onResponseDelegate({
+                data: undefined,
+                error: createNativeFetchErrorResponse(parseError.message),
+            });
+            return () => { };
+        }
+    }
+    if (imperativeAdapterIdentifier.includes('graphql')) {
+        try {
+            //we need to use the gql literal to convert into a document node
+            //in order to get through the gql imperative adapter
             configObject.query = gql `
                 ${configObject.query}
-            `;
-        }
-        catch (err) {
-            const parseError = normalizeError(err);
-            reportGraphqlQueryParseError(parseError);
-            // call the callback with error
-            onResponseDelegate({
-                data: undefined,
-                error: createNativeFetchErrorResponse(parseError.message),
-            });
-            return () => { };
-        }
-    }
-    try {
-        return imperativeAdapter.subscribe(configObject, buildAdapterRequestContext(nativeAdapterRequestContext), onResponseDelegate);
-    }
-    catch (err) {
-        if (isGql) {
-            reportGraphqlQueryParseError(err);
-        }
-        onResponseDelegate(buildInvalidConfigError(err));
-        return () => { };
-    }
-}
-/**
- * Checks if the given adapter id is a graphQL adapter
- *
- * @param imperativeAdapterIdentifier The adapter id to check
- * @returns true if the adapter is graphQL, false otherwise
- */
-function isGqlAdapter(imperativeAdapterIdentifier) {
-    return keys(gqlApi).indexOf(imperativeAdapterIdentifier) > -1;
-}
-/**
- *  Executes a DML adapter and calls the onResponse callback upon receiving a response.
- *
- * @param adapter : DML Adapter
- * @param configObject : parsed config
- * @param onResponse : OnResponse
- * @param nativeAdapterRequestContext: Specify cache policy, priority and observability parameters
- */
-function invokeDmlAdapter(adapter, configObject, onResponse, nativeAdapterRequestContext) {
-    try {
-        adapter(configObject, buildAdapterRequestContext(nativeAdapterRequestContext)).then((data) => {
-            onResponse({ data, error: undefined });
-        }, (error) => {
-            onResponse({ data: undefined, error });
-        });
-    }
-    catch (err) {
-        // For catching the synchronous error in adapter
-        onResponse(buildInvalidConfigError(err));
-    }
-}
-/**
- * Executes the specified adapter with the given adapterId and config. Then
- * it replaces the draft with the given id with the draft generated
- * by the mutating adapter.  Will call onResult callback once with data or error.
- *
- * This function throws an error if the given adapterId cannot be found, or if the
- * adapterId is not a mutating adapter, or if a draft isn't created, or if it
- * fails to parse the given config string.
- */
-function invokeAdapterWithDraftToReplace(adapterId, config, draftIdToReplace, onResponse, nativeAdapterRequestContext) {
-    draftManager.getQueue().then((draftInfo) => {
-        const draftIds = draftInfo.items.map((draft) => draft.id);
-        if (draftIds.includes(draftIdToReplace) === false) {
-            onResponse({
-                data: undefined,
-                error: createNativeFetchErrorResponse(DRAFT_DOESNT_EXIST_MESSAGE),
-            });
-            return;
-        }
-        const adapter = getDMLAdapterFromName(adapterId);
-        if (adapter === undefined) {
-            // This check is here for legacy purpose
-            // So the consumers still get the same errors
-            if (getImperativeAdapterFromName(imperativeAdapterKeyBuilder(adapterId)) !== undefined) {
-                onResponse({
-                    data: undefined,
-                    error: createNativeFetchErrorResponse(NON_MUTATING_ADAPTER_MESSAGE),
-                });
-                return;
-            }
-            throw Error(`adapter ${adapterId} not recognized`);
-        }
-        if (adapterId === 'deleteRecord') {
-            invokeAdapterWithDraftToReplaceDeleteRecord(adapter, config, draftIdToReplace, onResponse, nativeAdapterRequestContext);
-        }
-        else {
-            invokeDmlAdapter(adapter, parse(config), (responseValue) => {
-                const draftIds = draftIdsForResponseValue(responseValue);
-                if (responseValue.error === undefined &&
-                    draftIds !== undefined &&
-                    draftIds.length > 0) {
-                    const draftId = draftIds[draftIds.length - 1];
-                    draftManager.replaceAction(draftIdToReplace, draftId).then(() => {
-                        onResponse(responseValue);
-                    });
-                }
-                else {
-                    let response = responseValue;
-                    response.error = createNativeFetchErrorResponse(NO_DRAFT_CREATED_MESSAGE);
-                    onResponse(response);
-                }
-            }, nativeAdapterRequestContext);
-        }
-    });
-}
-/**
- * Executes the specified adapter with the given adapterId and config. Then
- * it sets the given metadata on the draft created by the mutating adapter.  Will call
- * onResult callback once with data or error.
- *
- * This function throws an error if the given adapterId cannot be found, or if the
- * adapterId is not a mutating adapter, or if a draft isn't created, or if it
- * fails to parse the given config string.
- */
-function invokeAdapterWithMetadata(adapterId, config, metadata, onResponse, nativeAdapterRequestContext) {
-    const adapter = getDMLAdapterFromName(adapterId);
-    if (adapter === undefined) {
-        // This check is here for legacy purpose
-        // So the consumers still get the same errors
-        if (getImperativeAdapterFromName(imperativeAdapterKeyBuilder(adapterId)) !== undefined) {
-            onResponse({
-                data: undefined,
-                error: createNativeFetchErrorResponse(NON_MUTATING_ADAPTER_MESSAGE),
-            });
-            return;
-        }
-        throw Error(`adapter ${adapterId} not recognized`);
-    }
-    if (adapterId === 'deleteRecord') {
-        invokeAdapterWithMetadataDeleteRecord(adapter, config, metadata, onResponse, nativeAdapterRequestContext);
-    }
-    else {
-        invokeDmlAdapter(adapter, parse(config), (responseValue) => {
-            const draftIds = draftIdsForResponseValue(responseValue);
-            if (responseValue.error === undefined &&
-                draftIds !== undefined &&
-                draftIds.length > 0) {
-                const draftId = draftIds[draftIds.length - 1];
-                draftManager.setMetadata(draftId, metadata).then(() => {
-                    onResponse(responseValue);
-                });
-            }
-            else {
-                let response = responseValue;
-                response.error = createNativeFetchErrorResponse(NO_DRAFT_CREATED_MESSAGE);
-                onResponse(response);
-            }
-        }, nativeAdapterRequestContext);
-    }
-}
-/*
-//TODO W-10284305: Remove this function in 238
-This is a special case version of the invokeAdapterWithMetadata function
-which should only be used for the deleteRecord wire adapter, since it does not
-contain record data in the result and has to do special querying of the draft queue
-*/
-function invokeAdapterWithMetadataDeleteRecord(adapter, config, metadata, onResponse, nativeAdapterRequestContext) {
-    const targetedRecordId = parse(config);
-    let priorDraftIds;
-    draftManager.getQueue().then((draftState) => {
-        priorDraftIds = draftState.items.map((item) => {
-            return item.id;
-        });
-        invokeDmlAdapter(adapter, parse(config), (responseValue) => {
-            if (responseValue.error === undefined &&
-                responseValue.errors === undefined &&
-                responseValue.data === undefined) {
-                draftManager.getQueue().then((newState) => {
-                    const draftIdsToFilter = priorDraftIds ? priorDraftIds : [];
-                    const newDrafts = newState.items;
-                    const addedDrafts = newDrafts.filter((item) => {
-                        const isNew = draftIdsToFilter.indexOf(item.id) < 0;
-                        const targetIdMatches = item.targetId === targetedRecordId;
-                        return isNew && targetIdMatches;
-                    });
-                    if (addedDrafts.length !== 1) {
-                        let response = {
-                            error: createNativeFetchErrorResponse(NO_DRAFT_CREATED_MESSAGE),
-                        };
-                        onResponse(response);
-                    }
-                    else {
-                        draftManager.setMetadata(addedDrafts[0].id, metadata).then(() => {
-                            onResponse(responseValue);
-                        });
-                    }
-                });
-            }
-            else {
-                let response = responseValue;
-                response.error = createNativeFetchErrorResponse(NO_DRAFT_CREATED_MESSAGE);
-                onResponse(response);
-            }
-        }, nativeAdapterRequestContext);
-    });
-}
-/*
-//TODO W-10284305: Remove this function in 238
-This is a special case version of the invokeAdapterWithDraftToReplace function
-which should only be used for the deleteRecord wire adapter, since it does not
-contain record data in the result and has to do special querying of the draft queue
-*/
-function invokeAdapterWithDraftToReplaceDeleteRecord(adapter, config, draftIdToReplace, onResponse, nativeAdapterRequestContext) {
-    const targetedRecordId = parse(config);
-    let priorDraftIds;
-    draftManager.getQueue().then((draftState) => {
-        priorDraftIds = draftState.items.map((item) => {
-            return item.id;
-        });
-        invokeDmlAdapter(adapter, parse(config), (responseValue) => {
-            if (responseValue.error === undefined &&
-                responseValue.errors === undefined &&
-                responseValue.data === undefined) {
-                draftManager.getQueue().then((newState) => {
-                    const draftIdsToFilter = priorDraftIds ? priorDraftIds : [];
-                    const newDrafts = newState.items;
-                    const addedDrafts = newDrafts.filter((item) => {
-                        const isNew = draftIdsToFilter.indexOf(item.id) < 0;
-                        const targetIdMatches = item.targetId === targetedRecordId;
-                        return isNew && targetIdMatches;
-                    });
-                    if (addedDrafts.length !== 1) {
-                        let response = {
-                            error: createNativeFetchErrorResponse(NO_DRAFT_CREATED_MESSAGE),
-                        };
-                        onResponse(response);
-                    }
-                    else {
-                        draftManager
-                            .replaceAction(draftIdToReplace, addedDrafts[0].id)
-                            .then(() => {
-                            onResponse(responseValue);
-                        });
-                    }
-                });
-            }
-            else {
-                let response = responseValue;
-                response.error = createNativeFetchErrorResponse(NO_DRAFT_CREATED_MESSAGE);
-                onResponse(response);
-            }
-        }, nativeAdapterRequestContext);
-    });
-}
-function draftIdsForResponseValue(response) {
-    if (response.data !== undefined &&
-        response.data.drafts !== undefined &&
-        response.data.drafts.draftActionIds !== undefined) {
-        return response.data.drafts.draftActionIds;
-    }
-    return undefined;
-}
-/**
- * Executes the specified adapter with the given adapterId and config.  Will call
- * onResponse callback once with data or error.
- *
- * This function throws an error if the given adapterId cannot be found or if it
- * fails to parse the given config string.
- */
-function invokeAdapter(adapterId, config, onResponse, nativeAdapterRequestContext) {
-    const onResponseDelegate = (value) => {
-        onResponse(buildNativeCallbackValue(value));
-    };
-    const imperativeAdapterIdentifier = imperativeAdapterKeyBuilder(adapterId);
-    const imperativeAdapter = getImperativeAdapterFromName(imperativeAdapterIdentifier);
-    const configObject = parse(config);
-    // currently all uiapi GET adapters have a corresponding imperative adapter
-    if (imperativeAdapter !== undefined) {
-        // Check if it's graphQl adapter
-        // Parse the query in that case
-        const isGql = isGqlAdapter(imperativeAdapterIdentifier);
-        if (isGql) {
-            try {
-                // gql config needs gql query string turned into AST object
-                configObject.query = parseAndVisit(configObject.query);
-            }
-            catch (err) {
-                const parseError = normalizeError(err);
-                reportGraphqlQueryParseError(parseError);
-                // call the callback with error
-                onResponseDelegate({
-                    data: undefined,
-                    error: createNativeFetchErrorResponse(parseError.message),
-                });
-                return;
-            }
-        }
-        //unstable_graphql_imperative
-        if (imperativeAdapterIdentifier.includes('graphql')) {
-            try {
-                //we need to use the gql literal to convert into a document node
-                //in order to get through the gql imperative adapter
+            `;
+        }
+        catch (err) {
+            const parseError = normalizeError(err);
+            reportGraphqlQueryParseError(parseError);
+            // call the callback with error
+            onResponseDelegate({
+                data: undefined,
+                error: createNativeFetchErrorResponse(parseError.message),
+            });
+            return () => { };
+        }
+    }
+    try {
+        return imperativeAdapter.subscribe(configObject, buildAdapterRequestContext(nativeAdapterRequestContext), onResponseDelegate);
+    }
+    catch (err) {
+        if (isGql) {
+            reportGraphqlQueryParseError(err);
+        }
+        onResponseDelegate(buildInvalidConfigError(err));
+        return () => { };
+    }
+}
+/**
+ * Checks if the given adapter id is a graphQL adapter
+ *
+ * @param imperativeAdapterIdentifier The adapter id to check
+ * @returns true if the adapter is graphQL, false otherwise
+ */
+function isGqlAdapter(imperativeAdapterIdentifier) {
+    return keys(gqlApi).indexOf(imperativeAdapterIdentifier) > -1;
+}
+/**
+ *  Executes a DML adapter and calls the onResponse callback upon receiving a response.
+ *
+ * @param adapter : DML Adapter
+ * @param configObject : parsed config
+ * @param onResponse : OnResponse
+ * @param nativeAdapterRequestContext: Specify cache policy, priority and observability parameters
+ */
+function invokeDmlAdapter(adapter, configObject, onResponse, nativeAdapterRequestContext) {
+    try {
+        adapter(configObject, buildAdapterRequestContext(nativeAdapterRequestContext)).then((data) => {
+            onResponse({ data, error: undefined });
+        }, (error) => {
+            onResponse({ data: undefined, error });
+        });
+    }
+    catch (err) {
+        // For catching the synchronous error in adapter
+        onResponse(buildInvalidConfigError(err));
+    }
+}
+/**
+ * Executes the specified adapter with the given adapterId and config. Then
+ * it replaces the draft with the given id with the draft generated
+ * by the mutating adapter.  Will call onResult callback once with data or error.
+ *
+ * This function throws an error if the given adapterId cannot be found, or if the
+ * adapterId is not a mutating adapter, or if a draft isn't created, or if it
+ * fails to parse the given config string.
+ */
+function invokeAdapterWithDraftToReplace(adapterId, config, draftIdToReplace, onResponse, nativeAdapterRequestContext) {
+    draftManager.getQueue().then((draftInfo) => {
+        const draftIds = draftInfo.items.map((draft) => draft.id);
+        if (draftIds.includes(draftIdToReplace) === false) {
+            onResponse({
+                data: undefined,
+                error: createNativeFetchErrorResponse(DRAFT_DOESNT_EXIST_MESSAGE),
+            });
+            return;
+        }
+        const adapter = getDMLAdapterFromName(adapterId);
+        if (adapter === undefined) {
+            // This check is here for legacy purpose
+            // So the consumers still get the same errors
+            if (getImperativeAdapterFromName(imperativeAdapterKeyBuilder(adapterId)) !== undefined) {
+                onResponse({
+                    data: undefined,
+                    error: createNativeFetchErrorResponse(NON_MUTATING_ADAPTER_MESSAGE),
+                });
+                return;
+            }
+            throw Error(`adapter ${adapterId} not recognized`);
+        }
+        if (adapterId === 'deleteRecord') {
+            invokeAdapterWithDraftToReplaceDeleteRecord(adapter, config, draftIdToReplace, onResponse, nativeAdapterRequestContext);
+        }
+        else {
+            invokeDmlAdapter(adapter, parse(config), (responseValue) => {
+                const draftIds = draftIdsForResponseValue(responseValue);
+                if (responseValue.error === undefined &&
+                    draftIds !== undefined &&
+                    draftIds.length > 0) {
+                    const draftId = draftIds[draftIds.length - 1];
+                    draftManager.replaceAction(draftIdToReplace, draftId).then(() => {
+                        onResponse(responseValue);
+                    });
+                }
+                else {
+                    let response = responseValue;
+                    response.error = createNativeFetchErrorResponse(NO_DRAFT_CREATED_MESSAGE);
+                    onResponse(response);
+                }
+            }, nativeAdapterRequestContext);
+        }
+    });
+}
+/**
+ * Executes the specified adapter with the given adapterId and config. Then
+ * it sets the given metadata on the draft created by the mutating adapter.  Will call
+ * onResult callback once with data or error.
+ *
+ * This function throws an error if the given adapterId cannot be found, or if the
+ * adapterId is not a mutating adapter, or if a draft isn't created, or if it
+ * fails to parse the given config string.
+ */
+function invokeAdapterWithMetadata(adapterId, config, metadata, onResponse, nativeAdapterRequestContext) {
+    const adapter = getDMLAdapterFromName(adapterId);
+    if (adapter === undefined) {
+        // This check is here for legacy purpose
+        // So the consumers still get the same errors
+        if (getImperativeAdapterFromName(imperativeAdapterKeyBuilder(adapterId)) !== undefined) {
+            onResponse({
+                data: undefined,
+                error: createNativeFetchErrorResponse(NON_MUTATING_ADAPTER_MESSAGE),
+            });
+            return;
+        }
+        throw Error(`adapter ${adapterId} not recognized`);
+    }
+    if (adapterId === 'deleteRecord') {
+        invokeAdapterWithMetadataDeleteRecord(adapter, config, metadata, onResponse, nativeAdapterRequestContext);
+    }
+    else {
+        invokeDmlAdapter(adapter, parse(config), async (responseValue) => {
+            const draftIds = draftIdsForResponseValue(responseValue);
+            if (responseValue.error === undefined &&
+                draftIds !== undefined &&
+                draftIds.length > 0) {
+                const draftId = draftIds[draftIds.length - 1];
+                const managerState = await draftManager.getQueue();
+                const existingMetadata = (managerState.items.find((i) => i.id === draftId) || {}).metadata || {};
+                draftManager
+                    .setMetadata(draftId, { ...existingMetadata, ...metadata })
+                    .then(() => {
+                    onResponse(responseValue);
+                });
+            }
+            else {
+                let response = responseValue;
+                response.error = createNativeFetchErrorResponse(NO_DRAFT_CREATED_MESSAGE);
+                onResponse(response);
+            }
+        }, nativeAdapterRequestContext);
+    }
+}
+/*
+//TODO W-10284305: Remove this function in 238
+This is a special case version of the invokeAdapterWithMetadata function
+which should only be used for the deleteRecord wire adapter, since it does not
+contain record data in the result and has to do special querying of the draft queue
+*/
+function invokeAdapterWithMetadataDeleteRecord(adapter, config, metadata, onResponse, nativeAdapterRequestContext) {
+    const targetedRecordId = parse(config);
+    let priorDraftIds;
+    draftManager.getQueue().then((draftState) => {
+        priorDraftIds = draftState.items.map((item) => {
+            return item.id;
+        });
+        invokeDmlAdapter(adapter, parse(config), (responseValue) => {
+            if (responseValue.error === undefined &&
+                responseValue.errors === undefined &&
+                responseValue.data === undefined) {
+                draftManager.getQueue().then((newState) => {
+                    const draftIdsToFilter = priorDraftIds ? priorDraftIds : [];
+                    const newDrafts = newState.items;
+                    const addedDrafts = newDrafts.filter((item) => {
+                        const isNew = draftIdsToFilter.indexOf(item.id) < 0;
+                        const targetIdMatches = item.targetId === targetedRecordId;
+                        return isNew && targetIdMatches;
+                    });
+                    if (addedDrafts.length !== 1) {
+                        let response = {
+                            error: createNativeFetchErrorResponse(NO_DRAFT_CREATED_MESSAGE),
+                        };
+                        onResponse(response);
+                    }
+                    else {
+                        draftManager.setMetadata(addedDrafts[0].id, metadata).then(() => {
+                            onResponse(responseValue);
+                        });
+                    }
+                });
+            }
+            else {
+                let response = responseValue;
+                response.error = createNativeFetchErrorResponse(NO_DRAFT_CREATED_MESSAGE);
+                onResponse(response);
+            }
+        }, nativeAdapterRequestContext);
+    });
+}
+/*
+//TODO W-10284305: Remove this function in 238
+This is a special case version of the invokeAdapterWithDraftToReplace function
+which should only be used for the deleteRecord wire adapter, since it does not
+contain record data in the result and has to do special querying of the draft queue
+*/
+function invokeAdapterWithDraftToReplaceDeleteRecord(adapter, config, draftIdToReplace, onResponse, nativeAdapterRequestContext) {
+    const targetedRecordId = parse(config);
+    let priorDraftIds;
+    draftManager.getQueue().then((draftState) => {
+        priorDraftIds = draftState.items.map((item) => {
+            return item.id;
+        });
+        invokeDmlAdapter(adapter, parse(config), (responseValue) => {
+            if (responseValue.error === undefined &&
+                responseValue.errors === undefined &&
+                responseValue.data === undefined) {
+                draftManager.getQueue().then((newState) => {
+                    const draftIdsToFilter = priorDraftIds ? priorDraftIds : [];
+                    const newDrafts = newState.items;
+                    const addedDrafts = newDrafts.filter((item) => {
+                        const isNew = draftIdsToFilter.indexOf(item.id) < 0;
+                        const targetIdMatches = item.targetId === targetedRecordId;
+                        return isNew && targetIdMatches;
+                    });
+                    if (addedDrafts.length !== 1) {
+                        let response = {
+                            error: createNativeFetchErrorResponse(NO_DRAFT_CREATED_MESSAGE),
+                        };
+                        onResponse(response);
+                    }
+                    else {
+                        draftManager
+                            .replaceAction(draftIdToReplace, addedDrafts[0].id)
+                            .then(() => {
+                            onResponse(responseValue);
+                        });
+                    }
+                });
+            }
+            else {
+                let response = responseValue;
+                response.error = createNativeFetchErrorResponse(NO_DRAFT_CREATED_MESSAGE);
+                onResponse(response);
+            }
+        }, nativeAdapterRequestContext);
+    });
+}
+function draftIdsForResponseValue(response) {
+    if (response.data !== undefined &&
+        response.data.drafts !== undefined &&
+        response.data.drafts.draftActionIds !== undefined) {
+        return response.data.drafts.draftActionIds;
+    }
+    if (response.data !== undefined &&
+        response.data.contentVersion !== undefined &&
+        response.data.contentVersion.drafts !== undefined &&
+        response.data.contentVersion.drafts.draftActionIds !== undefined) {
+        return response.data.contentVersion.drafts.draftActionIds;
+    }
+    return undefined;
+}
+/**
+ * Executes the specified adapter with the given adapterId and config.  Will call
+ * onResponse callback once with data or error.
+ *
+ * This function throws an error if the given adapterId cannot be found or if it
+ * fails to parse the given config string.
+ */
+function invokeAdapter(adapterId, config, onResponse, nativeAdapterRequestContext) {
+    const onResponseDelegate = (value) => {
+        onResponse(buildNativeCallbackValue(value));
+    };
+    const imperativeAdapterIdentifier = imperativeAdapterKeyBuilder(adapterId);
+    const imperativeAdapter = getImperativeAdapterFromName(imperativeAdapterIdentifier);
+    const configObject = parse(config);
+    // currently all uiapi GET adapters have a corresponding imperative adapter
+    if (imperativeAdapter !== undefined) {
+        // Check if it's graphQl adapter
+        // Parse the query in that case
+        const isGql = isGqlAdapter(imperativeAdapterIdentifier);
+        if (isGql) {
+            try {
+                // gql config needs gql query string turned into AST object
+                configObject.query = parseAndVisit(configObject.query);
+            }
+            catch (err) {
+                const parseError = normalizeError(err);
+                reportGraphqlQueryParseError(parseError);
+                // call the callback with error
+                onResponseDelegate({
+                    data: undefined,
+                    error: createNativeFetchErrorResponse(parseError.message),
+                });
+                return;
+            }
+        }
+        //unstable_graphql_imperative
+        if (imperativeAdapterIdentifier.includes('graphql')) {
+            try {
+                //we need to use the gql literal to convert into a document node
+                //in order to get through the gql imperative adapter
                 configObject.query = gql `
                     ${configObject.query}
-                `;
-            }
-            catch (err) {
-                const parseError = normalizeError(err);
-                reportGraphqlQueryParseError(parseError);
-                // call the callback with error
-                onResponseDelegate({
-                    data: undefined,
-                    error: createNativeFetchErrorResponse(parseError.message),
-                });
-                return;
-            }
-        }
-        try {
-            imperativeAdapter.invoke(configObject, buildAdapterRequestContext(nativeAdapterRequestContext), onResponseDelegate);
-        }
-        catch (err) {
-            if (isGql) {
-                reportGraphqlQueryParseError(err);
-            }
-            onResponseDelegate(buildInvalidConfigError(err));
-        }
-        return;
-    }
-    const adapter = getDMLAdapterFromName(adapterId);
-    if (adapter === undefined) {
-        throw Error(`adapter ${adapterId} not recognized`);
-    }
-    invokeDmlAdapter(adapter, configObject, onResponseDelegate, nativeAdapterRequestContext);
-}
-/**
- * @deprecated Use invokeAdapter or subscribeToAdapter instead
- *
- * W-9173084 Will remove this
- */
-function executeAdapter(adapterId, config, onSnapshot, nativeAdapterRequestContext) {
-    return subscribeToAdapter(adapterId, config, onSnapshot, nativeAdapterRequestContext);
-}
-/**
- * @deprecated Use invokeAdapter instead
- *
- * W-9173084 Will remove this
- */
-function executeMutatingAdapter(adapterId, config, onResult, nativeAdapterRequestContext) {
-    invokeAdapter(adapterId, config, onResult, nativeAdapterRequestContext);
+                `;
+            }
+            catch (err) {
+                const parseError = normalizeError(err);
+                reportGraphqlQueryParseError(parseError);
+                // call the callback with error
+                onResponseDelegate({
+                    data: undefined,
+                    error: createNativeFetchErrorResponse(parseError.message),
+                });
+                return;
+            }
+        }
+        try {
+            imperativeAdapter.invoke(configObject, buildAdapterRequestContext(nativeAdapterRequestContext), onResponseDelegate);
+        }
+        catch (err) {
+            if (isGql) {
+                reportGraphqlQueryParseError(err);
+            }
+            onResponseDelegate(buildInvalidConfigError(err));
+        }
+        return;
+    }
+    const adapter = getDMLAdapterFromName(adapterId);
+    if (adapter === undefined) {
+        throw Error(`adapter ${adapterId} not recognized`);
+    }
+    invokeDmlAdapter(adapter, configObject, onResponseDelegate, nativeAdapterRequestContext);
+}
+/**
+ * @deprecated Use invokeAdapter or subscribeToAdapter instead
+ *
+ * W-9173084 Will remove this
+ */
+function executeAdapter(adapterId, config, onSnapshot, nativeAdapterRequestContext) {
+    return subscribeToAdapter(adapterId, config, onSnapshot, nativeAdapterRequestContext);
+}
+/**
+ * @deprecated Use invokeAdapter instead
+ *
+ * W-9173084 Will remove this
+ */
+function executeMutatingAdapter(adapterId, config, onResult, nativeAdapterRequestContext) {
+    invokeAdapter(adapterId, config, onResult, nativeAdapterRequestContext);
 }
 
-/* istanbul ignore file */
-// A allowlist of methods that we allow to be proxied from another LDS instance
-const allowList = ['enqueue', 'getQueueActions'];
-/**
- * Implements the DraftQueue interface from nimbus-plugin-lds by passing requests
- * to the instance of the lds-drafts' DraftQueue implementation
- */
-const nimbusDraftQueue = {
-    callProxyMethod(methodName, serializedArgsArray, resultCallback, errorCallback) {
-        const method = draftQueue[methodName];
-        if (method === undefined) {
-            return errorCallback(stringify({
-                message: 'Method does not exist on the draft queue',
-            }));
-        }
-        if (allowList.includes(methodName) === false) {
-            return errorCallback(stringify({
-                message: `Method ${methodName} is not available for proxy invocation`,
-            }));
-        }
-        const parsedArgs = parse(serializedArgsArray);
-        // TODO [W-9933226]: we should validate the argument list based on which method is being called
-        if (isArray(parsedArgs) === false) {
-            return errorCallback(stringify({
-                message: 'expected array argument list',
-            }));
-        }
-        let methodResult = undefined;
-        try {
-            if (parsedArgs === undefined) {
-                methodResult = method.call(draftQueue);
-            }
-            else {
-                methodResult = method.call(draftQueue, ...parsedArgs);
-            }
-        }
-        catch (err) {
-            return errorCallback(stringify(err));
-        }
-        if (methodResult.then === undefined) {
-            return resultCallback(stringify(methodResult));
-        }
-        methodResult
-            .then((result) => {
-            resultCallback(stringify(result));
-        })
-            .catch((err) => {
-            errorCallback(stringify(err));
-        });
-    },
+/* istanbul ignore file */
+// A allowlist of methods that we allow to be proxied from another LDS instance
+const allowList = ['enqueue', 'getQueueActions'];
+/**
+ * Implements the DraftQueue interface from nimbus-plugin-lds by passing requests
+ * to the instance of the lds-drafts' DraftQueue implementation
+ */
+const nimbusDraftQueue = {
+    callProxyMethod(methodName, serializedArgsArray, resultCallback, errorCallback) {
+        const method = draftQueue[methodName];
+        if (method === undefined) {
+            return errorCallback(stringify({
+                message: 'Method does not exist on the draft queue',
+            }));
+        }
+        if (allowList.includes(methodName) === false) {
+            return errorCallback(stringify({
+                message: `Method ${methodName} is not available for proxy invocation`,
+            }));
+        }
+        const parsedArgs = parse(serializedArgsArray);
+        // TODO [W-9933226]: we should validate the argument list based on which method is being called
+        if (isArray(parsedArgs) === false) {
+            return errorCallback(stringify({
+                message: 'expected array argument list',
+            }));
+        }
+        let methodResult = undefined;
+        try {
+            if (parsedArgs === undefined) {
+                methodResult = method.call(draftQueue);
+            }
+            else {
+                methodResult = method.call(draftQueue, ...parsedArgs);
+            }
+        }
+        catch (err) {
+            return errorCallback(stringify(err));
+        }
+        if (methodResult.then === undefined) {
+            return resultCallback(stringify(methodResult));
+        }
+        methodResult
+            .then((result) => {
+            resultCallback(stringify(result));
+        })
+            .catch((err) => {
+            errorCallback(stringify(err));
+        });
+    },
 };
 
 /**
@@ -686,69 +696,69 @@ const nimbusDraftQueue = {
 const API_NAMESPACE = 'UiApi';
 const RECORD_REPRESENTATION_NAME = 'RecordRepresentation';
 
-let luvio = undefined;
-let uiApiRecordTTL;
-let metadataTTL;
-withDefaultLuvio((_luvio) => {
-    luvio = _luvio;
-    if (uiApiRecordTTL !== undefined) {
-        // Note: This should rarely get hit and the durable store implementation
-        // should have read write synchronization to protect against race conditions
-        // Here since we are on a synchronous path we cannot await the Promise
-        setUiApiRecordTTL(uiApiRecordTTL);
-    }
-    if (metadataTTL !== undefined) {
-        // Note: This should rarely get hit and the durable store implementation
-        // should have read write synchronization to protect against race conditions
-        // Here since we are on a synchronous path we cannot await the Promise
-        setMetadataTTL(metadataTTL);
-    }
-});
-function setUiApiRecordTTL(ttl) {
-    uiApiRecordTTL = ttl;
-    if (luvio === undefined) {
-        return Promise.resolve();
-    }
-    return luvio.storeSetTTLOverride(API_NAMESPACE, RECORD_REPRESENTATION_NAME, ttl);
-}
-function setMetadataTTL(ttl) {
-    metadataTTL = ttl;
-    if (luvio === undefined) {
-        return Promise.resolve();
-    }
-    return luvio.storeSetDefaultTTLOverride(ttl);
+let luvio = undefined;
+let uiApiRecordTTL;
+let metadataTTL;
+withDefaultLuvio((_luvio) => {
+    luvio = _luvio;
+    if (uiApiRecordTTL !== undefined) {
+        // Note: This should rarely get hit and the durable store implementation
+        // should have read write synchronization to protect against race conditions
+        // Here since we are on a synchronous path we cannot await the Promise
+        setUiApiRecordTTL(uiApiRecordTTL);
+    }
+    if (metadataTTL !== undefined) {
+        // Note: This should rarely get hit and the durable store implementation
+        // should have read write synchronization to protect against race conditions
+        // Here since we are on a synchronous path we cannot await the Promise
+        setMetadataTTL(metadataTTL);
+    }
+});
+function setUiApiRecordTTL(ttl) {
+    uiApiRecordTTL = ttl;
+    if (luvio === undefined) {
+        return Promise.resolve();
+    }
+    return luvio.storeSetTTLOverride(API_NAMESPACE, RECORD_REPRESENTATION_NAME, ttl);
+}
+function setMetadataTTL(ttl) {
+    metadataTTL = ttl;
+    if (luvio === undefined) {
+        return Promise.resolve();
+    }
+    return luvio.storeSetDefaultTTLOverride(ttl);
 }
 
-function createPrimingSession(config) {
-    const { createPrimingSession } = getRuntime();
-    const { primingEventHandler, concurrency, batchSize } = config;
-    const session = createPrimingSession({ concurrency, batchSize });
-    if (primingEventHandler) {
-        const { onError, onPrimed } = primingEventHandler;
-        if (onError) {
-            session.on('error', onError.bind(primingEventHandler));
-        }
-        if (onPrimed) {
-            session.on('primed', onPrimed.bind(primingEventHandler));
-        }
-    }
-    return {
-        enqueue: session.enqueue.bind(session),
-        cancel: session.cancel.bind(session),
-        on: session.on.bind(session),
-        once: session.once.bind(session),
-        off: session.off.bind(session),
-    };
+function createPrimingSession(config) {
+    const { createPrimingSession } = getRuntime();
+    const { primingEventHandler, concurrency, batchSize } = config;
+    const session = createPrimingSession({ concurrency, batchSize });
+    if (primingEventHandler) {
+        const { onError, onPrimed } = primingEventHandler;
+        if (onError) {
+            session.on('error', onError.bind(primingEventHandler));
+        }
+        if (onPrimed) {
+            session.on('primed', onPrimed.bind(primingEventHandler));
+        }
+    }
+    return {
+        enqueue: session.enqueue.bind(session),
+        cancel: session.cancel.bind(session),
+        on: session.on.bind(session),
+        once: session.once.bind(session),
+        off: session.off.bind(session),
+    };
 }
 
-if (process.env.NODE_ENV !== 'production') {
-    // eslint-disable-next-line no-undef
-    withDefaultLuvio((luvio) => {
-        // eslint-disable-next-line no-undef
-        const global = typeof globalThis === 'undefined' ? {} : globalThis;
-        global.luvio = luvio;
-    });
+if (process.env.NODE_ENV !== 'production') {
+    // eslint-disable-next-line no-undef
+    withDefaultLuvio((luvio) => {
+        // eslint-disable-next-line no-undef
+        const global = typeof globalThis === 'undefined' ? {} : globalThis;
+        global.luvio = luvio;
+    });
 }
 
 export { createPrimingSession, draftManager, draftQueue, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, invokeAdapter, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, setMetadataTTL, setUiApiRecordTTL, subscribeToAdapter };
-// version: 1.125.0-242b72352
+// version: 1.127.0-48f9732df