@salesforce/lds-adapters-apex 0.1.0-dev1

package/sfdc/index.js

@@ -0,0 +1,689 @@
+/**
+ * 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.
+ *  *******************************************************************************************
+ */
+/* proxy-compat-disable */
+import { serializeStructuredKey, deepFreeze, StoreKeyMap, StoreKeySet } from 'force/luvioEngine';
+export { getSObjectValue } from './lds-apex-static-utils';
+import { bindWireRefresh, refresh, createInstrumentedAdapter, createLDSAdapter, createImperativeAdapter, createWireAdapterConstructor } from 'force/ldsBindings';
+import { withDefaultLuvio } from 'force/ldsEngine';
+
+const { keys: ObjectKeys, create: ObjectCreate } = Object;
+const { stringify: JSONStringify } = JSON;
+const { isArray: ArrayIsArray } = Array;
+function untrustedIsObject(untrusted) {
+    return typeof untrusted === 'object' && untrusted !== null && ArrayIsArray(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(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(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/v66.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 { isArray } = Array;
+const { stringify } = JSON;
+
+function createLink(ref) {
+    return {
+        __ref: serializeStructuredKey(ref),
+    };
+}
+
+const CACHE_CONTROL = 'cache-control';
+// 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, timestamp) => {
+    // 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,
+        ingestionTimestamp: timestamp,
+    });
+    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 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 } = 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, config, snapshotRefreshOptions),
+    });
+}
+function onFetchResponseSuccess$1(luvio, config, resourceParams, response) {
+    const recordId = keyBuilderFromResourceParams$1(resourceParams);
+    const select = {
+        recordId,
+        node: { kind: 'Fragment', opaque: true, private: [], version: APEX_VERSION },
+        variables: {},
+    };
+    if (shouldCache(response)) {
+        const snapshot = ingestSuccess$1(luvio, resourceParams, response, {
+            config,
+            resolve: () => buildNetworkSnapshot$1(luvio, 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, config, _resourceParams, response) {
+    return Promise.resolve(luvio.errorSnapshot(response, {
+        config,
+        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions),
+    }));
+}
+function buildNetworkSnapshot$1(luvio, 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, config, resourceParams, response), 
+        // TODO [W-10490362]: Properly generate the response cache keys
+        () => {
+            return new StoreKeyMap();
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError$1(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
+    const { luvio, config } = context;
+    const { networkPriority, requestCorrelator, eventObservers, sourceContext } = coercedAdapterRequestContext;
+    const dispatchOptions = {
+        resourceRequestContext: {
+            requestCorrelator,
+            sourceContext,
+        },
+        eventObservers,
+    };
+    if (networkPriority !== 'normal') {
+        dispatchOptions.overrides = {
+            priority: networkPriority,
+        };
+    }
+    return buildNetworkSnapshot$1(luvio, 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 (untrustedConfig, 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 }, buildCachedSnapshotCachePolicy$1, buildNetworkSnapshotCachePolicy$1);
+    };
+}
+
+/**
+ * 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 + '}';
+}
+
+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/v66.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, _config, resourceParams, response) {
+    const recordId = keyBuilderFromResourceParams(resourceParams);
+    const select = {
+        recordId,
+        node: { kind: 'Fragment', opaque: true, private: [], version: APEX_VERSION },
+        variables: {},
+    };
+    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, _config, _resourceParams, response) {
+    return Promise.resolve(luvio.errorSnapshot(response));
+}
+function buildNetworkSnapshot(luvio, config, options) {
+    const resourceParams = createResourceParams(config);
+    const request = createResourceRequest(resourceParams);
+    return luvio.dispatchResourceRequest(request, options).then((response) => {
+        return luvio.handleSuccessResponse(() => onFetchResponseSuccess(luvio, config, resourceParams, response), 
+        // TODO [W-10490362]: Properly generate response cache keys
+        () => {
+            return new StoreKeyMap();
+        });
+    }, (response) => {
+        return luvio.handleErrorResponse(() => onFetchResponseError(luvio, config, resourceParams, response));
+    });
+}
+function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
+    const { luvio, config } = context;
+    const { networkPriority, requestCorrelator, eventObservers, sourceContext } = coercedAdapterRequestContext;
+    const dispatchOptions = {
+        resourceRequestContext: {
+            requestCorrelator,
+            sourceContext,
+        },
+        eventObservers,
+    };
+    if (networkPriority !== 'normal') {
+        dispatchOptions.overrides = {
+            priority: networkPriority,
+        };
+    }
+    return buildNetworkSnapshot(luvio, config, dispatchOptions);
+}
+function handleSnapshot(snapshot) {
+    if (snapshot.state === 'Error') {
+        throw snapshot.error;
+    }
+    return snapshot.data;
+}
+/**
+ * Returns a function that executes the supplied ldsAdapter,
+ * and handles unwrapping the snapshot to return to caller
+ *
+ * @param ldsAdapter adapter to be invoked
+ * @returns an ApexInvoker
+ */
+function invoker(ldsAdapter) {
+    return (config, requestContext) => {
+        const snapshotOrPromise = ldsAdapter(config, requestContext);
+        return Promise.resolve(snapshotOrPromise).then(handleSnapshot);
+    };
+}
+const invokerFactory = (luvio, invokerParams, adapterFactory) => {
+    const { namespace, classname, method, isContinuation } = invokerParams;
+    const ldsAdapter = adapterFactory(luvio, namespace, classname, method, isContinuation);
+    return invoker(ldsAdapter);
+};
+const postInvoker = (luvio, invokerParams) => {
+    return invokerFactory(luvio, invokerParams, postApexAdapterFactory);
+};
+const getInvoker = (luvio, invokerParams) => {
+    return invokerFactory(luvio, invokerParams, getApexAdapterFactory);
+};
+function postApexAdapterFactory(luvio, namespace, classname, method, isContinuation) {
+    return (config, 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);
+        return luvio.applyCachePolicy(requestContext || {}, { config: configPlus, luvio }, buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
+    };
+}
+
+const engineForPrefetcherMap = new Map();
+function registerPrefetcher(luvio, prefetcher) {
+    if (process.env.NODE_ENV !== 'production') {
+        if (engineForPrefetcherMap.has(luvio)) {
+            throw new Error('Environment error: Only one prefetcher per engine is allowed.');
+        }
+    }
+    engineForPrefetcherMap.set(luvio, prefetcher);
+}
+function getPrefetcherFor(luvio) {
+    return engineForPrefetcherMap.get(luvio);
+}
+function createGetApexAdapterWithPrediction(adapter, luvio, invokerParams, name) {
+    return (config, requestContext) => {
+        const prefetcher = getPrefetcherFor(luvio);
+        const result = adapter(config, requestContext);
+        // only save requests with a valid config.
+        if (result !== null &&
+            prefetcher !== undefined &&
+            !(requestContext && requestContext.excludeFromPredictions)) {
+            prefetcher.saveRequest({
+                adapterName: 'getApex',
+                config: {
+                    name,
+                    invokerParams,
+                    config,
+                },
+            });
+        }
+        return result;
+    };
+}
+
+const REFRESH_APEX_KEY = 'refreshApex';
+// export for @salesforce/apex
+const refreshApex = function (data) {
+    return refresh(data, REFRESH_APEX_KEY);
+};
+let luvio;
+withDefaultLuvio((_luvio) => {
+    luvio = _luvio;
+    bindWireRefresh(luvio);
+});
+/**
+ * Imperative GET Apex Adapter.
+ *
+ * @param namespace a one- to 15-character alphanumeric identifier that distinguishes a package and its contents from other packages
+ * @param classname name of class where method is defined
+ * @param method name of method defining the Apex code
+ * @param isContinuation used to specify if the Apex method is a Continuation
+ * @returns an ImperativeAdapter that uses the GET endpoint
+ */
+const getApexInvoker_imperative = function (namespace, classname, method, isContinuation) {
+    if (luvio === undefined) {
+        if (process.env.NODE_ENV !== 'production') {
+            throw new Error('cannot create Apex adapter before default luvio is set');
+        }
+    }
+    const adapterName = `getApex_${namespace}_${classname}_${method}_${isContinuation}`;
+    const adapterMetadata = {
+        apiFamily: 'Apex',
+        name: adapterName,
+    };
+    const getApexInstrumentedLdsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, adapterName, (luvio) => factory(luvio, { namespace, classname, method, isContinuation })), adapterMetadata);
+    return createImperativeAdapter(luvio, getApexInstrumentedLdsAdapter, adapterMetadata);
+};
+/**
+ * Apex
+ *
+ * The Apex invoker is dual purpose; it can be invoked imperatively or be provided to an @wire
+ * In order for this to work, LWC will look for the property "adapter" on the object, and check that
+ * it conforms to the WireAdapter interface.
+ */
+const getApexInvoker = function (namespace, classname, method, isContinuation, isCacheable) {
+    if (luvio === undefined) {
+        if (process.env.NODE_ENV !== 'production') {
+            throw new Error('cannot create Apex adapter before default luvio is set');
+        }
+    }
+    const adapterName = `getApex_${namespace}_${classname}_${method}_${isContinuation}`;
+    const adapterMetadata = {
+        apiFamily: 'Apex',
+        name: adapterName,
+    };
+    const apexInvoker = isCacheable ? getInvoker : postInvoker;
+    const invokeApexImperative = createLDSAdapter(luvio, adapterName, (luvio) => apexInvoker(luvio, {
+        namespace,
+        classname,
+        method,
+        isContinuation,
+    }));
+    invokeApexImperative.adapter = createWireAdapterConstructor(luvio, createInstrumentedAdapter(createGetApexAdapterWithPrediction(createLDSAdapter(luvio, adapterName, (luvio) => factory(luvio, {
+        namespace,
+        classname,
+        method,
+        isContinuation,
+    })), luvio, { namespace, classname, method, isContinuation }, adapterName), adapterMetadata), adapterMetadata);
+    return invokeApexImperative;
+};
+
+export { factory as GetApexWireAdapterFactory, getApexInvoker, getApexInvoker_imperative, refreshApex, registerPrefetcher };
+// version: 0.1.0-dev1-c978a7b010