@salesforce/lds-adapters-apex 1.282.0 → 1.284.0

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

@@ -106,7 +106,6 @@ function createLink(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
@@ -205,32 +204,6 @@ function shouldCache(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);
@@ -280,7 +253,7 @@ function ingestSuccess$1(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function buildCachedSnapshotCachePolicy$1(buildSnapshotContext, storeLookup) {
-    const { luvio, config, adapterContext } = buildSnapshotContext;
+    const { luvio, config } = buildSnapshotContext;
     const { apexClass, apexMethod, xSFDCAllowContinuation, methodParams } = config;
     const recordId = keyBuilder(apexClass, apexMethod, xSFDCAllowContinuation, methodParams);
     return storeLookup({
@@ -294,21 +267,20 @@ function buildCachedSnapshotCachePolicy$1(buildSnapshotContext, storeLookup) {
         variables: {},
     }, {
         config,
-        resolve: () => buildNetworkSnapshot$1(luvio, adapterContext, config, snapshotRefreshOptions),
+        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions),
     });
 }
-function onFetchResponseSuccess$1(luvio, context, config, resourceParams, response) {
+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: {},
     };
-    setCacheControlAdapterContext(context, recordId, response);
     if (shouldCache(response)) {
         const snapshot = ingestSuccess$1(luvio, resourceParams, response, {
             config,
-            resolve: () => buildNetworkSnapshot$1(luvio, context, config, snapshotRefreshOptions),
+            resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions),
         });
         return luvio.storeBroadcast().then(() => snapshot);
     }
@@ -322,27 +294,27 @@ function onFetchResponseSuccess$1(luvio, context, config, resourceParams, respon
         data: response.body,
     });
 }
-function onFetchResponseError$1(luvio, context, config, _resourceParams, response) {
+function onFetchResponseError$1(luvio, config, _resourceParams, response) {
     return Promise.resolve(luvio.errorSnapshot(response, {
         config,
-        resolve: () => buildNetworkSnapshot$1(luvio, context, config, snapshotRefreshOptions),
+        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions),
     }));
 }
-function buildNetworkSnapshot$1(luvio, context, config, options) {
+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, context, config, resourceParams, 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, context, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$1(luvio, config, resourceParams, response));
     });
 }
 function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
-    const { luvio, config, adapterContext } = context;
+    const { luvio, config } = context;
     const { networkPriority, requestCorrelator, eventObservers, sourceContext } = coercedAdapterRequestContext;
     const dispatchOptions = {
         resourceRequestContext: {
@@ -356,14 +328,14 @@ function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext
             priority: networkPriority,
         };
     }
-    return buildNetworkSnapshot$1(luvio, adapterContext, config, dispatchOptions);
+    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 luvio.withContext(function apex__getApex(untrustedConfig, context, requestContext) {
+    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
@@ -374,8 +346,8 @@ function getApexAdapterFactory(luvio, namespace, classname, method, isContinuati
             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 });
+        return luvio.applyCachePolicy(requestContext || {}, { config: configPlus, luvio }, buildCachedSnapshotCachePolicy$1, buildNetworkSnapshotCachePolicy$1);
+    };
 }
 
 /**
@@ -539,14 +511,13 @@ function buildCachedSnapshotCachePolicy(buildSnapshotContext, storeLookup) {
         variables: {},
     });
 }
-function onFetchResponseSuccess(luvio, context, _config, resourceParams, response) {
+function onFetchResponseSuccess(luvio, _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);
@@ -561,24 +532,24 @@ function onFetchResponseSuccess(luvio, context, _config, resourceParams, respons
         data: response.body,
     });
 }
-function onFetchResponseError(luvio, _context, _config, _resourceParams, response) {
+function onFetchResponseError(luvio, _config, _resourceParams, response) {
     return Promise.resolve(luvio.errorSnapshot(response));
 }
-function buildNetworkSnapshot(luvio, context, config, options) {
+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, context, config, resourceParams, 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, context, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError(luvio, config, resourceParams, response));
     });
 }
 function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
-    const { luvio, config, adapterContext } = context;
+    const { luvio, config } = context;
     const { networkPriority, requestCorrelator, eventObservers, sourceContext } = coercedAdapterRequestContext;
     const dispatchOptions = {
         resourceRequestContext: {
@@ -592,7 +563,7 @@ function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext)
             priority: networkPriority,
         };
     }
-    return buildNetworkSnapshot(luvio, adapterContext, config, dispatchOptions);
+    return buildNetworkSnapshot(luvio, config, dispatchOptions);
 }
 function handleSnapshot(snapshot) {
     if (snapshot.state === 'Error') {
@@ -625,20 +596,14 @@ const getInvoker = (luvio, invokerParams) => {
     return invokerFactory(luvio, invokerParams, getApexAdapterFactory);
 };
 function postApexAdapterFactory(luvio, namespace, classname, method, isContinuation) {
-    return luvio.withContext(function apex__postApex(config, context, requestContext) {
+    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);
-        // 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 });
+        return luvio.applyCachePolicy(requestContext || {}, { config: configPlus, luvio }, buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
+    };
 }
 
 /**

package/dist/es/es2018/types/src/util/shared.d.ts

@@ -1,4 +1,4 @@
-import type { AdapterContext, Luvio, ResourceIngest, FetchResponse } from '@luvio/engine';
+import type { Luvio, ResourceIngest, FetchResponse } from '@luvio/engine';
 interface ApexScopedModuleParams {
     namespace: string;
     classname: string;
@@ -16,7 +16,6 @@ export interface ApexAdapterConfig {
 export type BuildSnapshotContext = {
     luvio: Luvio;
     config: ApexAdapterConfig;
-    adapterContext: AdapterContext;
 };
 export declare const CACHE_CONTROL = "cache-control";
 export declare const SHARED_ADAPTER_CONTEXT_ID = "apex__shared";
@@ -37,8 +36,4 @@ export declare function keyBuilder(classname: string, method: string, isContinua
 export declare function configBuilder(config: any, classname: string, method: string, isContinuation: boolean): ApexAdapterConfig;
 export declare function apexClassnameBuilder(namespace: string, classname: string): string;
 export declare function shouldCache(response: FetchResponse<any>): boolean;
-export declare function getCacheableKey(recordId: string): string;
-export declare function setCacheControlAdapterContext(context: AdapterContext, recordId: string, response: FetchResponse<any>): void;
-export declare function isCacheable(config: ApexAdapterConfig, context: AdapterContext): boolean;
-export declare function checkAdapterContext(context: AdapterContext, recordId: string): boolean;
 export {};

package/dist/es/es2018/types/src/wire/getApex/index.d.ts

@@ -1,4 +1,4 @@
-import type { Adapter, AdapterContext, DispatchResourceRequestContext, ErrorResponse, FulfilledSnapshot, Luvio, FetchResponse, Snapshot, SnapshotRefresh, StaleSnapshot } from '@luvio/engine';
+import type { Adapter, DispatchResourceRequestContext, ErrorResponse, FulfilledSnapshot, Luvio, FetchResponse, Snapshot, SnapshotRefresh, StaleSnapshot } from '@luvio/engine';
 import type { AdapterValidationConfig } from '../../generated/adapters/adapter-utils';
 import type { ResourceRequestConfig } from '../../generated/resources/getByApexMethodAndApexClass';
 import type { ApexAdapterConfig, ApexInvokerParams } from '../../util/shared';
@@ -7,8 +7,8 @@ export declare const getByApexMethodAndApexClass_ConfigPropertyNames: AdapterVal
 export declare function createResourceParams(config: ApexAdapterConfig): ResourceRequestConfig;
 export declare function keyBuilderFromResourceParams(params: ResourceRequestConfig): string;
 export declare function ingestSuccess(luvio: Luvio, resourceParams: ResourceRequestConfig, response: FetchResponse<any>, snapshotRefresh?: SnapshotRefresh<any>): FulfilledSnapshot<any, any> | StaleSnapshot<any, any>;
-export declare function onFetchResponseSuccess(luvio: Luvio, context: AdapterContext, config: ApexAdapterConfig, resourceParams: ResourceRequestConfig, response: FetchResponse<any>): Promise<FulfilledSnapshot<any, any> | StaleSnapshot<any, any>>;
-export declare function onFetchResponseError(luvio: Luvio, context: AdapterContext, config: ApexAdapterConfig, _resourceParams: ResourceRequestConfig, response: ErrorResponse): Promise<import("@luvio/engine").ErrorSnapshot>;
-export declare function buildNetworkSnapshot(luvio: Luvio, context: AdapterContext, config: ApexAdapterConfig, options?: DispatchResourceRequestContext): Promise<Snapshot<any>>;
+export declare function onFetchResponseSuccess(luvio: Luvio, config: ApexAdapterConfig, resourceParams: ResourceRequestConfig, response: FetchResponse<any>): Promise<FulfilledSnapshot<any, any> | StaleSnapshot<any, any>>;
+export declare function onFetchResponseError(luvio: Luvio, config: ApexAdapterConfig, _resourceParams: ResourceRequestConfig, response: ErrorResponse): Promise<import("@luvio/engine").ErrorSnapshot>;
+export declare function buildNetworkSnapshot(luvio: Luvio, config: ApexAdapterConfig, options?: DispatchResourceRequestContext): Promise<Snapshot<any>>;
 export declare const factory: (luvio: Luvio, invokerParams: ApexInvokerParams) => Adapter<any, any>;
 export declare function getApexAdapterFactory(luvio: Luvio, namespace: string, classname: string, method: string, isContinuation: boolean): Adapter<any, any>;

package/dist/es/es2018/types/src/wire/postApex/index.d.ts

@@ -1,12 +1,12 @@
-import type { Adapter, AdapterContext, AdapterRequestContext, DispatchResourceRequestContext, ErrorResponse, FulfilledSnapshot, Luvio, FetchResponse, Snapshot, SnapshotRefresh, StaleSnapshot } from '@luvio/engine';
+import type { Adapter, AdapterRequestContext, DispatchResourceRequestContext, ErrorResponse, FulfilledSnapshot, Luvio, FetchResponse, Snapshot, SnapshotRefresh, StaleSnapshot } from '@luvio/engine';
 import type { ResourceRequestConfig } from '../../generated/resources/postByApexMethodAndApexClass';
 import type { ApexAdapterConfig, ApexInvokerParams } from '../../util/shared';
 export declare function createResourceParams(config: ApexAdapterConfig): ResourceRequestConfig;
 export declare function keyBuilderFromResourceParams(params: ResourceRequestConfig): string;
 export declare function ingestSuccess(luvio: Luvio, resourceParams: ResourceRequestConfig, response: FetchResponse<any>, snapshotRefresh?: SnapshotRefresh<any>): FulfilledSnapshot<any, any> | StaleSnapshot<any, any>;
-export declare function onFetchResponseSuccess(luvio: Luvio, context: AdapterContext, _config: ApexAdapterConfig, resourceParams: ResourceRequestConfig, response: FetchResponse<any>): Promise<FulfilledSnapshot<any, any> | StaleSnapshot<any, any>>;
-export declare function onFetchResponseError(luvio: Luvio, _context: AdapterContext, _config: ApexAdapterConfig, _resourceParams: ResourceRequestConfig, response: ErrorResponse): Promise<import("@luvio/engine").ErrorSnapshot>;
-export declare function buildNetworkSnapshot(luvio: Luvio, context: AdapterContext, config: ApexAdapterConfig, options?: DispatchResourceRequestContext): Promise<Snapshot<any>>;
+export declare function onFetchResponseSuccess(luvio: Luvio, _config: ApexAdapterConfig, resourceParams: ResourceRequestConfig, response: FetchResponse<any>): Promise<FulfilledSnapshot<any, any> | StaleSnapshot<any, any>>;
+export declare function onFetchResponseError(luvio: Luvio, _config: ApexAdapterConfig, _resourceParams: ResourceRequestConfig, response: ErrorResponse): Promise<import("@luvio/engine").ErrorSnapshot>;
+export declare function buildNetworkSnapshot(luvio: Luvio, config: ApexAdapterConfig, options?: DispatchResourceRequestContext): Promise<Snapshot<any>>;
 type ApexInvoker = (config: unknown, requestContext: AdapterRequestContext) => Promise<any>;
 export type ApexAdapterFactory<Config, DataType> = (luvio: Luvio, namespace: string, classname: string, method: string, isContinuation: boolean) => Adapter<Config, DataType>;
 export declare const postInvoker: (luvio: Luvio, invokerParams: ApexInvokerParams) => ApexInvoker;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-adapters-apex",
-    "version": "1.282.0",
+    "version": "1.284.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "Wire adapters for Apex",
     "main": "dist/es/es2018/apex-service.js",
@@ -30,12 +30,12 @@
         ]
     },
     "dependencies": {
-        "@salesforce/lds-bindings": "^1.282.0",
-        "@salesforce/lds-default-luvio": "^1.282.0"
+        "@salesforce/lds-bindings": "^1.284.0",
+        "@salesforce/lds-default-luvio": "^1.284.0"
     },
     "devDependencies": {
-        "@salesforce/lds-compiler-plugins": "^1.282.0",
-        "@salesforce/lds-karma": "^1.282.0"
+        "@salesforce/lds-compiler-plugins": "^1.284.0",
+        "@salesforce/lds-karma": "^1.284.0"
     },
     "nx": {
         "targets": {

package/sfdc/index.js

@@ -116,7 +116,6 @@ function createLink(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
@@ -215,32 +214,6 @@ function shouldCache(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);
@@ -290,7 +263,7 @@ function ingestSuccess$1(luvio, resourceParams, response, snapshotRefresh) {
     return snapshot;
 }
 function buildCachedSnapshotCachePolicy$1(buildSnapshotContext, storeLookup) {
-    const { luvio, config, adapterContext } = buildSnapshotContext;
+    const { luvio, config } = buildSnapshotContext;
     const { apexClass, apexMethod, xSFDCAllowContinuation, methodParams } = config;
     const recordId = keyBuilder(apexClass, apexMethod, xSFDCAllowContinuation, methodParams);
     return storeLookup({
@@ -304,21 +277,20 @@ function buildCachedSnapshotCachePolicy$1(buildSnapshotContext, storeLookup) {
         variables: {},
     }, {
         config,
-        resolve: () => buildNetworkSnapshot$1(luvio, adapterContext, config, snapshotRefreshOptions),
+        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions),
     });
 }
-function onFetchResponseSuccess$1(luvio, context, config, resourceParams, response) {
+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: {},
     };
-    setCacheControlAdapterContext(context, recordId, response);
     if (shouldCache(response)) {
         const snapshot = ingestSuccess$1(luvio, resourceParams, response, {
             config,
-            resolve: () => buildNetworkSnapshot$1(luvio, context, config, snapshotRefreshOptions),
+            resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions),
         });
         return luvio.storeBroadcast().then(() => snapshot);
     }
@@ -332,27 +304,27 @@ function onFetchResponseSuccess$1(luvio, context, config, resourceParams, respon
         data: response.body,
     });
 }
-function onFetchResponseError$1(luvio, context, config, _resourceParams, response) {
+function onFetchResponseError$1(luvio, config, _resourceParams, response) {
     return Promise.resolve(luvio.errorSnapshot(response, {
         config,
-        resolve: () => buildNetworkSnapshot$1(luvio, context, config, snapshotRefreshOptions),
+        resolve: () => buildNetworkSnapshot$1(luvio, config, snapshotRefreshOptions),
     }));
 }
-function buildNetworkSnapshot$1(luvio, context, config, options) {
+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, context, config, resourceParams, 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, context, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError$1(luvio, config, resourceParams, response));
     });
 }
 function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext) {
-    const { luvio, config, adapterContext } = context;
+    const { luvio, config } = context;
     const { networkPriority, requestCorrelator, eventObservers, sourceContext } = coercedAdapterRequestContext;
     const dispatchOptions = {
         resourceRequestContext: {
@@ -366,14 +338,14 @@ function buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext
             priority: networkPriority,
         };
     }
-    return buildNetworkSnapshot$1(luvio, adapterContext, config, dispatchOptions);
+    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 luvio.withContext(function apex__getApex(untrustedConfig, context, requestContext) {
+    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
@@ -384,8 +356,8 @@ function getApexAdapterFactory(luvio, namespace, classname, method, isContinuati
             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 });
+        return luvio.applyCachePolicy(requestContext || {}, { config: configPlus, luvio }, buildCachedSnapshotCachePolicy$1, buildNetworkSnapshotCachePolicy$1);
+    };
 }
 
 /**
@@ -518,14 +490,13 @@ function buildCachedSnapshotCachePolicy(buildSnapshotContext, storeLookup) {
         variables: {},
     });
 }
-function onFetchResponseSuccess(luvio, context, _config, resourceParams, response) {
+function onFetchResponseSuccess(luvio, _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);
@@ -540,24 +511,24 @@ function onFetchResponseSuccess(luvio, context, _config, resourceParams, respons
         data: response.body,
     });
 }
-function onFetchResponseError(luvio, _context, _config, _resourceParams, response) {
+function onFetchResponseError(luvio, _config, _resourceParams, response) {
     return Promise.resolve(luvio.errorSnapshot(response));
 }
-function buildNetworkSnapshot(luvio, context, config, options) {
+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, context, config, resourceParams, 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, context, config, resourceParams, response));
+        return luvio.handleErrorResponse(() => onFetchResponseError(luvio, config, resourceParams, response));
     });
 }
 function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
-    const { luvio, config, adapterContext } = context;
+    const { luvio, config } = context;
     const { networkPriority, requestCorrelator, eventObservers, sourceContext } = coercedAdapterRequestContext;
     const dispatchOptions = {
         resourceRequestContext: {
@@ -571,7 +542,7 @@ function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext)
             priority: networkPriority,
         };
     }
-    return buildNetworkSnapshot(luvio, adapterContext, config, dispatchOptions);
+    return buildNetworkSnapshot(luvio, config, dispatchOptions);
 }
 function handleSnapshot(snapshot) {
     if (snapshot.state === 'Error') {
@@ -604,20 +575,14 @@ const getInvoker = (luvio, invokerParams) => {
     return invokerFactory(luvio, invokerParams, getApexAdapterFactory);
 };
 function postApexAdapterFactory(luvio, namespace, classname, method, isContinuation) {
-    return luvio.withContext(function apex__postApex(config, context, requestContext) {
+    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);
-        // 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 });
+        return luvio.applyCachePolicy(requestContext || {}, { config: configPlus, luvio }, buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
+    };
 }
 
 const REFRESH_APEX_KEY = 'refreshApex';
@@ -683,4 +648,4 @@ const getApexInvoker = function (namespace, classname, method, isContinuation, i
 };
 
 export { getApexInvoker, getApexInvoker_imperative, refreshApex };
-// version: 1.282.0-dd2e9831c
+// version: 1.284.0-8b78b708e