@salesforce/lds-adapters-apex 0.131.0

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

@@ -0,0 +1,668 @@
+/**
+ * Copyright (c) 2022, Salesforce, Inc.,
+ * All rights reserved.
+ * For full license text, see the LICENSE.txt file
+ */
+
+import { serializeStructuredKey, StoreKeyMap, StoreKeySet } from '@luvio/engine';
+
+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: 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 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 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 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 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;
+}
+
+export { invoker as GetApexInvoker, factory as GetApexWireAdapterFactory, getSObjectValue };