@salesforce/lds-worker-api 0.131.0

package/dist/sfdc/es/ldsWorkerApi.js

@@ -0,0 +1,761 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+/*  *******************************************************************************************
+ *  ATTENTION!
+ *  THIS IS A GENERATED FILE FROM https://github.com/salesforce-experience-platform-emu/lds-lightning-platform
+ *  If you would like to contribute to LDS, please follow the steps outlined in the git repo.
+ *  Any changes made to this file in p4 will be automatically overwritten.
+ *  *******************************************************************************************
+ */
+import { parseAndVisit, gql } from 'force/ldsGraphqlParser';
+import * as lightningAppsApi from 'lightning/uiAppsApi';
+import * as unstableLightningAppsApi from 'lightning/unstable_uiAppsApi';
+import * as lightningLayoutApi from 'lightning/uiLayoutApi';
+import * as unstableLightningLayoutApi from 'lightning/unstable_uiLayoutApi';
+import * as lightningListApi from 'lightning/uiListApi';
+import * as unstableLightningListApi from 'lightning/unstable_uiListApi';
+import * as lightningLookupsApi from 'lightning/uiLookupsApi';
+import * as unstableLightningLookupsApi from 'lightning/unstable_uiLookupsApi';
+import * as lightningObjectApi from 'lightning/uiObjectInfoApi';
+import * as unstableLightningObjectApi from 'lightning/unstable_uiObjectInfoApi';
+import * as lightningRecordActionsApi from 'lightning/uiRecordActionsApi';
+import * as unstableLightningRecordActionsApi from 'lightning/unstable_uiRecordActionsApi';
+import * as lightningRecordApi from 'lightning/uiRecordApi';
+import * as unstableLightningRecordApi from 'lightning/unstable_uiRecordApi';
+import * as lightningRecordAvatarApi from 'lightning/uiRecordAvatarApi';
+import * as unstableLightningRecordAvatarApi from 'lightning/unstable_uiRecordAvatarApi';
+import * as lightningRelatedListApi from 'lightning/uiRelatedListApi';
+import * as unstableLightningRelatedListApi from 'lightning/unstable_uiRelatedListApi';
+import * as lightningGraphQLApi from 'lightning/uiGraphQLApi';
+import { createContentDocumentAndVersion, createContentVersion } from 'force/ldsAdaptersUiapi';
+import * as gqlApi from 'force/ldsAdaptersGraphql';
+import { getRuntime, reportGraphqlQueryParseError } from 'native/ldsRuntimeMobile';
+export { registerReportObserver } from 'native/ldsRuntimeMobile';
+import { HttpStatusCode } from 'force/luvioEngine';
+import { withDefaultLuvio } from 'native/ldsEngineMobile';
+
+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 { 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));
+}
+
+/**
+ * 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 && observabilityContext !== null) {
+        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), 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);
+}
+
+/* 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, 
+    // NOTE: the other side of the proxy is expecting an error message string
+    // (not a JSON serialized Error object)
+    errorCallback) {
+        const method = draftQueue[methodName];
+        if (method === undefined) {
+            return errorCallback('Method does not exist on the draft queue');
+        }
+        if (allowList.includes(methodName) === false) {
+            return errorCallback(`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('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(normalizeError(err).message);
+        }
+        if (methodResult.then === undefined) {
+            return resultCallback(stringify(methodResult));
+        }
+        methodResult
+            .then((result) => {
+            resultCallback(stringify(result));
+        })
+            .catch((err) => {
+            errorCallback(normalizeError(err).message);
+        });
+    },
+};
+
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+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);
+}
+
+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;
+    });
+}
+
+export { createPrimingSession, draftManager, draftQueue, executeAdapter, executeMutatingAdapter, getImperativeAdapterNames, invokeAdapter, invokeAdapterWithDraftToReplace, invokeAdapterWithMetadata, nimbusDraftQueue, setMetadataTTL, setUiApiRecordTTL, subscribeToAdapter };
+// version: 0.131.0-5e4201fa2