@salesforce/lds-adapters-apex 1.100.1

package/dist/umd/es2018/apex-service.js

@@ -0,0 +1,678 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@luvio/engine')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@luvio/engine'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.apexService = {}, global.engine));
+})(this, (function (exports, engine) { 'use strict';
+
+    const { keys: ObjectKeys$1, freeze: ObjectFreeze$1, create: ObjectCreate$1 } = Object;
+    const { stringify: JSONStringify } = JSON;
+    const { isArray: ArrayIsArray$1 } = Array;
+    function untrustedIsObject(untrusted) {
+        return typeof untrusted === 'object' && untrusted !== null && ArrayIsArray$1(untrusted) === false;
+    }
+    const snapshotRefreshOptions = {
+        overrides: {
+            headers: {
+                'Cache-Control': 'no-cache',
+            },
+        }
+    };
+    /**
+     * A deterministic JSON stringify implementation. Heavily adapted from https://github.com/epoberezkin/fast-json-stable-stringify.
+     * This is needed because insertion order for JSON.stringify(object) affects output:
+     * JSON.stringify({a: 1, b: 2})
+     *      "{"a":1,"b":2}"
+     * JSON.stringify({b: 2, a: 1})
+     *      "{"b":2,"a":1}"
+     * @param data Data to be JSON-stringified.
+     * @returns JSON.stringified value with consistent ordering of keys.
+     */
+    function stableJSONStringify$1(node) {
+        // This is for Date values.
+        if (node && node.toJSON && typeof node.toJSON === 'function') {
+            // eslint-disable-next-line no-param-reassign
+            node = node.toJSON();
+        }
+        if (node === undefined) {
+            return;
+        }
+        if (typeof node === 'number') {
+            return isFinite(node) ? '' + node : 'null';
+        }
+        if (typeof node !== 'object') {
+            return JSONStringify(node);
+        }
+        let i;
+        let out;
+        if (ArrayIsArray$1(node)) {
+            out = '[';
+            for (i = 0; i < node.length; i++) {
+                if (i) {
+                    out += ',';
+                }
+                out += stableJSONStringify$1(node[i]) || 'null';
+            }
+            return out + ']';
+        }
+        if (node === null) {
+            return 'null';
+        }
+        const keys = ObjectKeys$1(node).sort();
+        out = '';
+        for (i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const value = stableJSONStringify$1(node[key]);
+            if (!value) {
+                continue;
+            }
+            if (out) {
+                out += ',';
+            }
+            out += JSONStringify(key) + ':' + value;
+        }
+        return '{' + out + '}';
+    }
+    const keyPrefix = 'Apex';
+
+    function createResourceRequest$1(config) {
+        const headers = {};
+        const header_xSFDCAllowContinuation = config.headers.xSFDCAllowContinuation;
+        if (header_xSFDCAllowContinuation !== undefined) {
+            headers['X-SFDC-Allow-Continuation'] = header_xSFDCAllowContinuation;
+        }
+        return {
+            baseUri: '/lwr/apex/v58.0',
+            basePath: '/' + config.urlParams.apexClass + '/' + config.urlParams.apexMethod + '',
+            method: 'get',
+            body: null,
+            urlParams: config.urlParams,
+            queryParams: config.queryParams,
+            headers,
+            priority: 'normal',
+        };
+    }
+
+    const { create, keys, values } = Object;
+    const { hasOwnProperty } = Object.prototype;
+    const { isArray } = Array;
+    const { stringify } = JSON;
+
+    const { freeze: ObjectFreeze, keys: ObjectKeys, create: ObjectCreate, assign: ObjectAssign } = Object;
+    const { isArray: ArrayIsArray } = Array;
+    function deepFreeze(value) {
+        // No need to freeze primitives
+        if (typeof value !== 'object' || value === null) {
+            return;
+        }
+        if (ArrayIsArray(value)) {
+            for (let i = 0, len = value.length; i < len; i += 1) {
+                deepFreeze(value[i]);
+            }
+        }
+        else {
+            const keys = ObjectKeys(value);
+            for (let i = 0, len = keys.length; i < len; i += 1) {
+                deepFreeze(value[keys[i]]);
+            }
+        }
+        ObjectFreeze(value);
+    }
+    function createLink(ref) {
+        return {
+            __ref: engine.serializeStructuredKey(ref),
+        };
+    }
+
+    const CACHE_CONTROL = 'cache-control';
+    const SHARED_ADAPTER_CONTEXT_ID = 'apex__shared';
+    // eslint-disable-next-line @salesforce/lds/no-invalid-todo
+    // TODO: APEX_TTL, apexResponseEquals, apexResponseIngest, and validateAdapterConfig should have been code generated
+    // however compiler does not support response body type any so hand roll for now
+    /**
+     * Time to live for the Apex cache value. 5 minutes.
+     */
+    const APEX_TTL = 5 * 60 * 1000;
+    // apex is essentially versionless, we can never know the shape of apex data
+    // so we will rely on components to code defensively. All apex data will be ingested
+    // and looked up with this version
+    const APEX_VERSION = 'APEX_V_1';
+    const APEX_STORE_METADATA_PARAMS = {
+        ttl: APEX_TTL,
+        namespace: keyPrefix,
+        representationName: '',
+        version: APEX_VERSION,
+    };
+    function apexResponseEquals(existing, incoming) {
+        return stringify(incoming) === stringify(existing);
+    }
+    const apexResponseIngest = (input, path, luvio, store) => {
+        // skip validation and normalization, since input type is any
+        const key = path.fullPath;
+        const incomingRecord = input;
+        const existingRecord = store.readEntry(key);
+        // freeze on ingest (luvio.opaque)
+        deepFreeze(incomingRecord);
+        if (existingRecord === undefined ||
+            apexResponseEquals(existingRecord, incomingRecord) === false) {
+            luvio.storePublish(key, incomingRecord);
+        }
+        luvio.publishStoreMetadata(key, APEX_STORE_METADATA_PARAMS);
+        return createLink(key);
+    };
+    function validateAdapterConfig(untrustedConfig) {
+        if (untrustedIsObject(untrustedConfig)) {
+            const values$1 = values(untrustedConfig);
+            return values$1.indexOf(undefined) === -1 ? untrustedConfig : null;
+        }
+        return untrustedConfig;
+    }
+    /**
+     * A standard delimiter when producing cache keys.
+     */
+    const KEY_DELIM = ':';
+    function isEmptyParam(param) {
+        return (param === undefined ||
+            param === null ||
+            (typeof param === 'object' && keys(param).length === 0));
+    }
+    function keyBuilder(classname, method, isContinuation, params) {
+        return [
+            classname.replace('__', KEY_DELIM),
+            method,
+            isContinuation,
+            isEmptyParam(params) ? '' : stableJSONStringify$1(params),
+        ].join(KEY_DELIM);
+    }
+    function configBuilder(config, classname, method, isContinuation) {
+        return {
+            apexMethod: method,
+            apexClass: classname,
+            methodParams: config,
+            xSFDCAllowContinuation: isContinuation + '',
+        };
+    }
+    function apexClassnameBuilder(namespace, classname) {
+        return namespace !== '' ? `${namespace}__${classname}` : classname;
+    }
+    function isCacheControlValueCacheable(value) {
+        if (value === undefined || value === null || typeof value !== 'string') {
+            return false;
+        }
+        return value.indexOf('no-cache') < 0 && value.indexOf('no-store') < 0;
+    }
+    function getCacheControlHeaderValue(headers) {
+        if (headers === undefined) {
+            return undefined;
+        }
+        // header fields are case-insensitive according to
+        // https://www.w3.org/Protocols/rfc2616/rfc2616-sec4.html#sec4.2
+        const headerKeys = keys(headers);
+        for (let i = 0, len = headerKeys.length; i < len; i += 1) {
+            const key = headerKeys[i];
+            if (key.toLowerCase() === CACHE_CONTROL) {
+                return headers[key];
+            }
+        }
+        return undefined;
+    }
+    function shouldCache(response) {
+        const { headers } = response;
+        const headerValue = getCacheControlHeaderValue(headers);
+        return isCacheControlValueCacheable(headerValue);
+    }
+    function getCacheableKey(recordId) {
+        return `${recordId}_cacheable`;
+    }
+    function set(context, recordId, value) {
+        const key = getCacheableKey(recordId);
+        context.set(key, value);
+    }
+    function get(context, key) {
+        return context.get(getCacheableKey(key));
+    }
+    function setCacheControlAdapterContext(context, recordId, response) {
+        const { headers } = response;
+        const headerValue = getCacheControlHeaderValue(headers);
+        if (headerValue !== undefined) {
+            set(context, recordId, headerValue);
+        }
+    }
+    function isCacheable(config, context) {
+        const { apexClass, apexMethod, xSFDCAllowContinuation, methodParams } = config;
+        const recordId = keyBuilder(apexClass, apexMethod, xSFDCAllowContinuation, methodParams);
+        return checkAdapterContext(context, recordId);
+    }
+    function checkAdapterContext(context, recordId) {
+        const contextValue = get(context, recordId);
+        return isCacheControlValueCacheable(contextValue);
+    }
+
+    function createResourceParams$1(config) {
+        const queryParams = create(null);
+        if (!isEmptyParam(config.methodParams)) {
+            queryParams.methodParams = config.methodParams;
+        }
+        return {
+            queryParams,
+            urlParams: {
+                apexMethod: config.apexMethod,
+                apexClass: config.apexClass,
+            },
+            headers: {
+                xSFDCAllowContinuation: config.xSFDCAllowContinuation,
+            },
+        };
+    }
+    function keyBuilderFromResourceParams$1(params) {
+        let classname = params.urlParams.apexClass.replace('__', KEY_DELIM);
+        return [
+            classname,
+            params.urlParams.apexMethod,
+            params.headers.xSFDCAllowContinuation,
+            isEmptyParam(params.queryParams.methodParams)
+                ? ''
+                : stableJSONStringify$1(params.queryParams.methodParams),
+        ].join(KEY_DELIM);
+    }
+    function ingestSuccess$1(luvio, resourceParams, response, snapshotRefresh) {
+        const { body } = response;
+        const recordId = keyBuilderFromResourceParams$1(resourceParams);
+        const select = {
+            recordId,
+            node: { kind: 'Fragment', opaque: true, private: [], version: APEX_VERSION },
+            variables: {},
+        };
+        luvio.storeIngest(recordId, apexResponseIngest, body);
+        const snapshot = luvio.storeLookup(select, snapshotRefresh);
+        if (process.env.NODE_ENV !== 'production') {
+            if (response.headers !== undefined && snapshot.state !== 'Fulfilled') {
+                throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+            }
+            if (!(snapshot.state === 'Fulfilled' || snapshot.state === 'Stale')) {
+                throw new Error('Invalid resource response. Expected resource response to result in Fulfilled or Stale snapshot');
+            }
+        }
+        return snapshot;
+    }
+    function buildCachedSnapshotCachePolicy$1(buildSnapshotContext, storeLookup) {
+        const { luvio, config, adapterContext } = buildSnapshotContext;
+        const { apexClass, apexMethod, xSFDCAllowContinuation, methodParams } = config;
+        const recordId = keyBuilder(apexClass, apexMethod, xSFDCAllowContinuation, methodParams);
+        return storeLookup({
+            recordId: recordId,
+            node: {
+                kind: 'Fragment',
+                opaque: true,
+                private: [],
+                version: APEX_VERSION,
+            },
+            variables: {},
+        }, {
+            config,
+            resolve: () => buildNetworkSnapshot$1(luvio, adapterContext, config, snapshotRefreshOptions),
+        });
+    }
+    function onFetchResponseSuccess$1(luvio, context, config, resourceParams, response) {
+        const recordId = keyBuilderFromResourceParams$1(resourceParams);
+        const select = {
+            recordId,
+            node: { kind: 'Fragment', opaque: true, private: [], version: APEX_VERSION },
+            variables: {},
+        };
+        setCacheControlAdapterContext(context, recordId, response);
+        if (shouldCache(response)) {
+            const snapshot = ingestSuccess$1(luvio, resourceParams, response, {
+                config,
+                resolve: () => buildNetworkSnapshot$1(luvio, context, config, snapshotRefreshOptions),
+            });
+            return luvio.storeBroadcast().then(() => snapshot);
+        }
+        // if Cache-Control is not set or set to 'no-cache', return a synthetic snapshot
+        return Promise.resolve({
+            recordId,
+            variables: {},
+            seenRecords: new engine.StoreKeySet(),
+            select,
+            state: 'Fulfilled',
+            data: response.body,
+        });
+    }
+    function onFetchResponseError$1(luvio, context, config, _resourceParams, response) {
+        return Promise.resolve(luvio.errorSnapshot(response, {
+            config,
+            resolve: () => buildNetworkSnapshot$1(luvio, context, config, snapshotRefreshOptions),
+        }));
+    }
+    function buildNetworkSnapshot$1(luvio, context, config, options) {
+        const resourceParams = createResourceParams$1(config);
+        const request = createResourceRequest$1(resourceParams);
+        return luvio.dispatchResourceRequest(request, options).then((response) => {
+            return luvio.handleSuccessResponse(() => onFetchResponseSuccess$1(luvio, context, config, resourceParams, response), 
+            // TODO [W-10490362]: Properly generate the response cache keys
+            () => {
+                return new engine.StoreKeyMap();
+            });
+        }, (response) => {
+            return luvio.handleErrorResponse(() => onFetchResponseError$1(luvio, context, config, resourceParams, response));
+        });
+    }
+    function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
+        const { luvio, config, adapterContext } = context;
+        const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
+        const dispatchOptions = {
+            resourceRequestContext: {
+                requestCorrelator,
+            },
+            eventObservers,
+        };
+        if (networkPriority !== 'normal') {
+            dispatchOptions.overrides = {
+                priority: networkPriority,
+            };
+        }
+        return buildNetworkSnapshot$1(luvio, adapterContext, config, dispatchOptions);
+    }
+    const factory = (luvio, invokerParams) => {
+        const { namespace, classname, method, isContinuation } = invokerParams;
+        return getApexAdapterFactory(luvio, namespace, classname, method, isContinuation);
+    };
+    function getApexAdapterFactory(luvio, namespace, classname, method, isContinuation) {
+        return luvio.withContext(function apex__getApex(untrustedConfig, context, requestContext) {
+            // Even though the config is of type `any`,
+            // validation is required here because `undefined`
+            // values on a wire mean that properties on the component
+            // used in the config have not been loaded yet.
+            const config = validateAdapterConfig(untrustedConfig);
+            // Invalid or incomplete config
+            if (config === null) {
+                return null;
+            }
+            const configPlus = configBuilder(config, apexClassnameBuilder(namespace, classname), method, isContinuation);
+            return luvio.applyCachePolicy(requestContext || {}, { config: configPlus, luvio, adapterContext: context }, buildCachedSnapshotCachePolicy$1, buildNetworkSnapshotCachePolicy$1);
+        }, { contextId: SHARED_ADAPTER_CONTEXT_ID });
+    }
+
+    /**
+     * A deterministic JSON stringify implementation. Heavily adapted from https://github.com/epoberezkin/fast-json-stable-stringify.
+     * This is needed because insertion order for JSON.stringify(object) affects output:
+     * JSON.stringify({a: 1, b: 2})
+     *      "{"a":1,"b":2}"
+     * JSON.stringify({b: 2, a: 1})
+     *      "{"b":2,"a":1}"
+     * @param data Data to be JSON-stringified.
+     * @returns JSON.stringified value with consistent ordering of keys.
+     */
+    function stableJSONStringify(node) {
+        // This is for Date values.
+        if (node && node.toJSON && typeof node.toJSON === 'function') {
+            // eslint-disable-next-line no-param-reassign
+            node = node.toJSON();
+        }
+        if (node === undefined) {
+            return;
+        }
+        if (typeof node === 'number') {
+            return isFinite(node) ? '' + node : 'null';
+        }
+        if (typeof node !== 'object') {
+            return stringify(node);
+        }
+        let i;
+        let out;
+        if (isArray(node)) {
+            out = '[';
+            for (i = 0; i < node.length; i++) {
+                if (i) {
+                    out += ',';
+                }
+                out += stableJSONStringify(node[i]) || 'null';
+            }
+            return out + ']';
+        }
+        if (node === null) {
+            return 'null';
+        }
+        const keys$1 = keys(node).sort();
+        out = '';
+        for (i = 0; i < keys$1.length; i++) {
+            const key = keys$1[i];
+            const value = stableJSONStringify(node[key]);
+            if (!value) {
+                continue;
+            }
+            if (out) {
+                out += ',';
+            }
+            out += stringify(key) + ':' + value;
+        }
+        return '{' + out + '}';
+    }
+    /**
+     * Returns the field API name, qualified with an object name if possible.
+     * @param value The value from which to get the qualified field API name.
+     * @return The qualified field API name.
+     */
+    function getFieldApiName(value) {
+        if (typeof value === 'string') {
+            return value;
+        }
+        else if (value &&
+            typeof value.objectApiName === 'string' &&
+            typeof value.fieldApiName === 'string') {
+            return value.objectApiName + '.' + value.fieldApiName;
+        }
+        throw new TypeError('Value is not a string or FieldId.');
+    }
+    /**
+     * Split the object API name and field API name from a qualified field name.
+     * Eg: Opportunity.Title returns ['Opportunity', 'Title']
+     * Eg: Opportunity.Account.Name returns ['Opportunity', 'Account.Name']
+     * @param fieldApiName The qualified field name.
+     * @return The object and field API names.
+     */
+    function splitQualifiedFieldApiName(fieldApiName) {
+        const idx = fieldApiName.indexOf('.');
+        if (idx < 1) {
+            // object api name must non-empty
+            throw new TypeError('Value does not include an object API name.');
+        }
+        return [fieldApiName.substring(0, idx), fieldApiName.substring(idx + 1)];
+    }
+
+    function createResourceRequest(config) {
+        const headers = {};
+        const header_xSFDCAllowContinuation = config.headers.xSFDCAllowContinuation;
+        if (header_xSFDCAllowContinuation !== undefined) {
+            headers['X-SFDC-Allow-Continuation'] = header_xSFDCAllowContinuation;
+        }
+        return {
+            baseUri: '/lwr/apex/v58.0',
+            basePath: '/' + config.urlParams.apexClass + '/' + config.urlParams.apexMethod + '',
+            method: 'post',
+            body: config.body,
+            urlParams: config.urlParams,
+            queryParams: {},
+            headers,
+            priority: 'normal',
+        };
+    }
+
+    function createResourceParams(config) {
+        return {
+            urlParams: {
+                apexMethod: config.apexMethod,
+                apexClass: config.apexClass,
+            },
+            body: config.methodParams,
+            headers: {
+                xSFDCAllowContinuation: config.xSFDCAllowContinuation,
+            },
+        };
+    }
+    function keyBuilderFromResourceParams(params) {
+        let classname = params.urlParams.apexClass.replace('__', KEY_DELIM);
+        return [
+            classname,
+            params.urlParams.apexMethod,
+            params.headers.xSFDCAllowContinuation,
+            isEmptyParam(params.body) ? '' : stableJSONStringify(params.body),
+        ].join(KEY_DELIM);
+    }
+    function ingestSuccess(luvio, resourceParams, response, snapshotRefresh) {
+        const { body } = response;
+        const recordId = keyBuilderFromResourceParams(resourceParams);
+        const select = {
+            recordId,
+            node: { kind: 'Fragment', opaque: true, private: [], version: APEX_VERSION },
+            variables: {},
+        };
+        luvio.storeIngest(recordId, apexResponseIngest, body);
+        const snapshot = luvio.storeLookup(select, snapshotRefresh);
+        if (process.env.NODE_ENV !== 'production') {
+            if (response.headers !== undefined && snapshot.state !== 'Fulfilled') {
+                throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
+            }
+            if (!(snapshot.state === 'Fulfilled' || snapshot.state === 'Stale')) {
+                throw new Error('Invalid resource response. Expected resource response to result in Fulfilled or Stale snapshot');
+            }
+        }
+        return snapshot;
+    }
+    function buildCachedSnapshotCachePolicy(buildSnapshotContext, storeLookup) {
+        const { config } = buildSnapshotContext;
+        const { apexClass, apexMethod, xSFDCAllowContinuation, methodParams } = config;
+        const recordId = keyBuilder(apexClass, apexMethod, xSFDCAllowContinuation, methodParams);
+        return storeLookup({
+            recordId: recordId,
+            node: {
+                kind: 'Fragment',
+                opaque: true,
+                private: [],
+                version: APEX_VERSION,
+            },
+            variables: {},
+        });
+    }
+    function onFetchResponseSuccess(luvio, context, _config, resourceParams, response) {
+        const recordId = keyBuilderFromResourceParams(resourceParams);
+        const select = {
+            recordId,
+            node: { kind: 'Fragment', opaque: true, private: [], version: APEX_VERSION },
+            variables: {},
+        };
+        setCacheControlAdapterContext(context, recordId, response);
+        if (shouldCache(response)) {
+            const snapshot = ingestSuccess(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }
+        // if Cache-Control is not set or set to 'no-cache', return a synthetic snapshot
+        return Promise.resolve({
+            recordId,
+            variables: {},
+            seenRecords: new engine.StoreKeySet(),
+            select,
+            state: 'Fulfilled',
+            data: response.body,
+        });
+    }
+    function onFetchResponseError(luvio, _context, _config, _resourceParams, response) {
+        return Promise.resolve(luvio.errorSnapshot(response));
+    }
+    function buildNetworkSnapshot(luvio, context, config, options) {
+        const resourceParams = createResourceParams(config);
+        const request = createResourceRequest(resourceParams);
+        return luvio.dispatchResourceRequest(request, options).then((response) => {
+            return luvio.handleSuccessResponse(() => onFetchResponseSuccess(luvio, context, config, resourceParams, response), 
+            // TODO [W-10490362]: Properly generate response cache keys
+            () => {
+                return new engine.StoreKeyMap();
+            });
+        }, (response) => {
+            return luvio.handleErrorResponse(() => onFetchResponseError(luvio, context, config, resourceParams, response));
+        });
+    }
+    function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
+        const { luvio, config, adapterContext } = context;
+        const { networkPriority, requestCorrelator, eventObservers } = coercedAdapterRequestContext;
+        const dispatchOptions = {
+            resourceRequestContext: {
+                requestCorrelator,
+            },
+            eventObservers,
+        };
+        if (networkPriority !== 'normal') {
+            dispatchOptions.overrides = {
+                priority: networkPriority,
+            };
+        }
+        return buildNetworkSnapshot(luvio, adapterContext, config, dispatchOptions);
+    }
+    const invoker = (luvio, invokerParams) => {
+        const { namespace, classname, method, isContinuation } = invokerParams;
+        const ldsAdapter = postApexAdapterFactory(luvio, namespace, classname, method, isContinuation);
+        return getInvoker(ldsAdapter);
+    };
+    function getInvoker(ldsAdapter) {
+        return (config, requestContext) => {
+            const snapshotOrPromise = ldsAdapter(config, requestContext);
+            return Promise.resolve(snapshotOrPromise).then((snapshot) => {
+                if (snapshot.state === 'Error') {
+                    throw snapshot.error;
+                }
+                return snapshot.data;
+            });
+        };
+    }
+    function postApexAdapterFactory(luvio, namespace, classname, method, isContinuation) {
+        return luvio.withContext(function apex__postApex(config, context, requestContext) {
+            // config validation is unnecessary for this imperative adapter
+            // due to the config being of type `any`.
+            // however, we have special config validation for the wire adapter,
+            // explanation in getApex
+            const configPlus = configBuilder(config, apexClassnameBuilder(namespace, classname), method, isContinuation);
+            // if this response isn't meant to be cached then pass a buildCached
+            // func that returns undefined, that way cache policy impls will know
+            // not to do any cache lookups
+            const buildCached = isCacheable(configPlus, context)
+                ? buildCachedSnapshotCachePolicy
+                : () => undefined;
+            return luvio.applyCachePolicy(requestContext || {}, { config: configPlus, luvio, adapterContext: context }, buildCached, buildNetworkSnapshotCachePolicy);
+        }, { contextId: SHARED_ADAPTER_CONTEXT_ID });
+    }
+
+    /**
+     * Gets a field value from an Apex sObject.
+     * @param sobject The sObject holding the field.
+     * @param field The qualified API name of the field to return.
+     * @returns The field's value. If it doesn't exist, undefined is returned.
+     */
+    function getSObjectValue(sObject, field) {
+        if (untrustedIsObject(sObject) === false) {
+            return;
+        }
+        const unqualifiedField = splitQualifiedFieldApiName(getFieldApiName(field))[1];
+        const fields = unqualifiedField.split('.');
+        let ret = sObject;
+        for (let i = 0, fieldsLength = fields.length; i < fieldsLength; i++) {
+            const nextField = fields[i];
+            if (!hasOwnProperty.call(ret, nextField)) {
+                return undefined;
+            }
+            ret = ret[nextField];
+        }
+        return ret;
+    }
+
+    exports.GetApexInvoker = invoker;
+    exports.GetApexWireAdapterFactory = factory;
+    exports.getSObjectValue = getSObjectValue;
+
+    Object.defineProperty(exports, '__esModule', { value: true });
+
+}));