@salesforce/lds-adapters-platform-formula 1.244.0 → 1.246.0

package/dist/es/es2018/platform-formula.js

@@ -4,7 +4,7 @@
  * For full license text, see the LICENSE.txt file
  */
 
-import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$1, typeCheckConfig as typeCheckConfig$1, StoreKeyMap, createResourceParams as createResourceParams$1 } from '@luvio/engine';
+import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$1, typeCheckConfig as typeCheckConfig$1 } from '@luvio/engine';
 
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys, create: ObjectCreate } = Object;
@@ -41,13 +41,6 @@ function untrustedIsObject(untrusted) {
 function areRequiredParametersPresent(config, configPropertyNames) {
     return configPropertyNames.parameters.required.every(req => req in config);
 }
-const snapshotRefreshOptions = {
-    overrides: {
-        headers: {
-            'Cache-Control': 'no-cache',
-        },
-    }
-};
 function generateParamConfigMetadata(name, required, resourceType, typeCheckShape, isArrayShape = false, coerceFn) {
     return {
         name,
@@ -79,7 +72,7 @@ function createLink(ref) {
 }
 
 const TTL = 100;
-const VERSION = "6cbd1c5cb74b9f1dee47794fd77fc37b";
+const VERSION = "c06ad095a0c68e00a7cf4b94f01f937b";
 function validate(obj, path = 'FormulaExplanationRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -99,6 +92,15 @@ function validate(obj, path = 'FormulaExplanationRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType = 'FormulaExplanationRepresentation';
+function keyBuilder(luvio, config) {
+    return keyPrefix + '::' + RepresentationType + ':' + config.generationId;
+}
+function keyBuilderFromType(luvio, object) {
+    const keyParams = {
+        generationId: object.generationId
+    };
+    return keyBuilder(luvio, keyParams);
+}
 function normalize(input, existing, path, luvio, store, timestamp) {
     return input;
 }
@@ -139,14 +141,14 @@ const ingest = function FormulaExplanationRepresentationIngest(input, path, luvi
             throw validateError;
         }
     }
-    const key = path.fullPath;
+    const key = keyBuilderFromType(luvio, input);
     const ttlToUse = TTL;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize, "Formula", VERSION, RepresentationType, equals);
     return createLink(key);
 };
 function getTypeCacheKeys(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = fullPathFactory();
+    const rootKey = keyBuilderFromType(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
         representationName: RepresentationType,
@@ -157,21 +159,18 @@ function getTypeCacheKeys(rootKeySet, luvio, input, fullPathFactory) {
 function select(luvio, params) {
     return select$1();
 }
-function keyBuilder$1(luvio, params) {
-    return keyPrefix + '::FormulaExplanationRepresentation:(' + 'entityName:' + params.body.entityName + '::' + 'formula:' + params.body.formula + '::' + 'formulaType:' + params.body.formulaType + '::' + 'returnType:' + params.body.returnType + ')';
-}
 function getResponseCacheKeys(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys(storeKeyMap, luvio, response, () => keyBuilder$1(luvio, resourceParams));
+    getTypeCacheKeys(storeKeyMap, luvio, response);
 }
-function ingestSuccess(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilder$1(luvio, resourceParams);
+    const key = keyBuilderFromType(luvio, body);
     luvio.storeIngest(key, ingest, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select(),
         variables: {},
-    }, snapshotRefresh);
+    });
     if (process.env.NODE_ENV !== 'production') {
         if (snapshot.state !== 'Fulfilled') {
             throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
@@ -180,18 +179,6 @@ function ingestSuccess(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$1(luvio, params);
-    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
-    const storeMetadataParams = {
-        ttl: TTL,
-        namespace: keyPrefix,
-        version: VERSION,
-        representationName: RepresentationType
-    };
-    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
-    return errorSnapshot;
-}
 function createResourceRequest(config) {
     const headers = {};
     return {
@@ -215,10 +202,6 @@ const getExplanation_ConfigPropertyMetadata = [
 ];
 const getExplanation_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, getExplanation_ConfigPropertyMetadata);
 const createResourceParams = /*#__PURE__*/ createResourceParams$1(getExplanation_ConfigPropertyMetadata);
-function keyBuilder(luvio, config) {
-    const resourceParams = createResourceParams(config);
-    return keyBuilder$1(luvio, resourceParams);
-}
 function typeCheckConfig(untrustedConfig) {
     const config = {};
     typeCheckConfig$1(untrustedConfig, config, getExplanation_ConfigPropertyMetadata);
@@ -237,62 +220,33 @@ function validateAdapterConfig(untrustedConfig, configPropertyNames) {
     }
     return config;
 }
-function adapterFragment(luvio, config) {
-    createResourceParams(config);
-    return select();
-}
-function onFetchResponseSuccess(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess(luvio, resourceParams, response, {
-        config,
-        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
-    });
-    return luvio.storeBroadcast().then(() => snapshot);
-}
-function onFetchResponseError(luvio, config, resourceParams, response) {
-    const snapshot = ingestError(luvio, resourceParams, response, {
-        config,
-        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
-    });
-    return luvio.storeBroadcast().then(() => snapshot);
-}
 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), () => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
             const cache = new StoreKeyMap();
             getResponseCacheKeys(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError(luvio, config, resourceParams, response));
+        deepFreeze(response);
+        throw response;
     });
 }
-function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext, buildNetworkSnapshot, 'get', false);
-}
-function buildCachedSnapshotCachePolicy(context, storeLookup) {
-    const { luvio, config } = context;
-    const selector = {
-        recordId: keyBuilder(luvio, config),
-        node: adapterFragment(luvio, config),
-        variables: {},
+const getExplanationAdapterFactory = (luvio) => {
+    return function getExplanation(untrustedConfig) {
+        const config = validateAdapterConfig(untrustedConfig, getExplanation_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "getExplanation"');
+        }
+        return buildNetworkSnapshot(luvio, config);
     };
-    const cacheSnapshot = storeLookup(selector, {
-        config,
-        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
-    });
-    return cacheSnapshot;
-}
-const getExplanationAdapterFactory = (luvio) => function Formula__getExplanation(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig(untrustedConfig, getExplanation_ConfigPropertyNames);
-    // Invalid or incomplete config
-    if (config === null) {
-        return null;
-    }
-    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
 };
 
 export { getExplanationAdapterFactory };

package/dist/es/es2018/types/src/generated/adapters/getExplanation.d.ts

@@ -1,4 +1,4 @@
-import { AdapterConfigMetadata as $64$luvio_engine_AdapterConfigMetadata, Luvio as $64$luvio_engine_Luvio, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, Fragment as $64$luvio_engine_Fragment, Snapshot as $64$luvio_engine_Snapshot, FetchResponse as $64$luvio_engine_FetchResponse, ErrorResponse as $64$luvio_engine_ErrorResponse, DispatchResourceRequestContext as $64$luvio_engine_DispatchResourceRequestContext, CoercedAdapterRequestContext as $64$luvio_engine_CoercedAdapterRequestContext, StoreLookup as $64$luvio_engine_StoreLookup, AdapterFactory as $64$luvio_engine_AdapterFactory } from '@luvio/engine';
+import { AdapterConfigMetadata as $64$luvio_engine_AdapterConfigMetadata, Luvio as $64$luvio_engine_Luvio, DispatchResourceRequestContext as $64$luvio_engine_DispatchResourceRequestContext, AdapterFactory as $64$luvio_engine_AdapterFactory } from '@luvio/engine';
 import { Untrusted as adapter$45$utils_Untrusted, AdapterValidationConfig as adapter$45$utils_AdapterValidationConfig } from './adapter-utils';
 import { ResourceRequestConfig as resources_postConnectFormulaEinsteinExplain_ResourceRequestConfig } from '../resources/postConnectFormulaEinsteinExplain';
 import { FormulaExplanationRepresentation as types_FormulaExplanationRepresentation_FormulaExplanationRepresentation } from '../types/FormulaExplanationRepresentation';
@@ -12,19 +12,7 @@ export interface GetExplanationConfig {
     returnType: string;
 }
 export declare const createResourceParams: (config: GetExplanationConfig) => resources_postConnectFormulaEinsteinExplain_ResourceRequestConfig;
-export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: GetExplanationConfig): string;
-export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: GetExplanationConfig): $64$luvio_engine_NormalizedKeyMetadata;
 export declare function typeCheckConfig(untrustedConfig: adapter$45$utils_Untrusted<GetExplanationConfig>): adapter$45$utils_Untrusted<GetExplanationConfig>;
 export declare function validateAdapterConfig(untrustedConfig: unknown, configPropertyNames: adapter$45$utils_AdapterValidationConfig): GetExplanationConfig | null;
-export declare function adapterFragment(luvio: $64$luvio_engine_Luvio, config: GetExplanationConfig): $64$luvio_engine_Fragment;
-export declare function buildCachedSnapshot(luvio: $64$luvio_engine_Luvio, config: GetExplanationConfig): $64$luvio_engine_Snapshot<types_FormulaExplanationRepresentation_FormulaExplanationRepresentation, any>;
-export declare function onFetchResponseSuccess(luvio: $64$luvio_engine_Luvio, config: GetExplanationConfig, resourceParams: resources_postConnectFormulaEinsteinExplain_ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_FormulaExplanationRepresentation_FormulaExplanationRepresentation>): Promise<import("@luvio/engine").FulfilledSnapshot<types_FormulaExplanationRepresentation_FormulaExplanationRepresentation, {}> | import("@luvio/engine").StaleSnapshot<types_FormulaExplanationRepresentation_FormulaExplanationRepresentation, {}> | import("@luvio/engine").PendingSnapshot<types_FormulaExplanationRepresentation_FormulaExplanationRepresentation, any>>;
-export declare function onFetchResponseError(luvio: $64$luvio_engine_Luvio, config: GetExplanationConfig, resourceParams: resources_postConnectFormulaEinsteinExplain_ResourceRequestConfig, response: $64$luvio_engine_ErrorResponse): Promise<import("@luvio/engine").ErrorSnapshot>;
-export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: GetExplanationConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<$64$luvio_engine_Snapshot<types_FormulaExplanationRepresentation_FormulaExplanationRepresentation, any>>;
-export type BuildSnapshotContext = {
-    luvio: $64$luvio_engine_Luvio;
-    config: GetExplanationConfig;
-};
-export declare function buildNetworkSnapshotCachePolicy(context: BuildSnapshotContext, coercedAdapterRequestContext: $64$luvio_engine_CoercedAdapterRequestContext): Promise<$64$luvio_engine_Snapshot<types_FormulaExplanationRepresentation_FormulaExplanationRepresentation, any>>;
-export declare function buildCachedSnapshotCachePolicy(context: BuildSnapshotContext, storeLookup: $64$luvio_engine_StoreLookup<types_FormulaExplanationRepresentation_FormulaExplanationRepresentation>): $64$luvio_engine_Snapshot<types_FormulaExplanationRepresentation_FormulaExplanationRepresentation, any>;
+export declare function buildNetworkSnapshot(luvio: $64$luvio_engine_Luvio, config: GetExplanationConfig, options?: $64$luvio_engine_DispatchResourceRequestContext): Promise<import("@luvio/engine").FulfilledSnapshot<types_FormulaExplanationRepresentation_FormulaExplanationRepresentation, {}> | import("@luvio/engine").StaleSnapshot<types_FormulaExplanationRepresentation_FormulaExplanationRepresentation, {}> | import("@luvio/engine").PendingSnapshot<types_FormulaExplanationRepresentation_FormulaExplanationRepresentation, any>>;
 export declare const getExplanationAdapterFactory: $64$luvio_engine_AdapterFactory<GetExplanationConfig, types_FormulaExplanationRepresentation_FormulaExplanationRepresentation>;

package/dist/es/es2018/types/src/generated/artifacts/sfdc.d.ts

@@ -1,3 +1,2 @@
 declare let getExplanation: any;
-declare let getExplanation_imperative: any;
-export { getExplanation, getExplanation_imperative };
+export { getExplanation, };

package/dist/es/es2018/types/src/generated/resources/postConnectFormulaEinsteinExplain.d.ts

@@ -1,4 +1,4 @@
-import { Luvio as $64$luvio_engine_Luvio, Fragment as $64$luvio_engine_Fragment, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, FetchResponse as $64$luvio_engine_FetchResponse, SnapshotRefresh as $64$luvio_engine_SnapshotRefresh, FulfilledSnapshot as $64$luvio_engine_FulfilledSnapshot, StaleSnapshot as $64$luvio_engine_StaleSnapshot, PendingSnapshot as $64$luvio_engine_PendingSnapshot, ErrorResponse as $64$luvio_engine_ErrorResponse, ErrorSnapshot as $64$luvio_engine_ErrorSnapshot, ResourceRequest as $64$luvio_engine_ResourceRequest } from '@luvio/engine';
+import { Luvio as $64$luvio_engine_Luvio, Fragment as $64$luvio_engine_Fragment, FetchResponse as $64$luvio_engine_FetchResponse, FulfilledSnapshot as $64$luvio_engine_FulfilledSnapshot, StaleSnapshot as $64$luvio_engine_StaleSnapshot, PendingSnapshot as $64$luvio_engine_PendingSnapshot, ResourceRequest as $64$luvio_engine_ResourceRequest } from '@luvio/engine';
 import { FormulaExplanationRepresentation as types_FormulaExplanationRepresentation_FormulaExplanationRepresentation } from '../types/FormulaExplanationRepresentation';
 export interface ResourceRequestConfig {
     body: {
@@ -9,10 +9,7 @@ export interface ResourceRequestConfig {
     };
 }
 export declare function select(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_Fragment;
-export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): string;
-export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig): $64$luvio_engine_NormalizedKeyMetadata;
 export declare function getResponseCacheKeys(storeKeyMap: any, luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: types_FormulaExplanationRepresentation_FormulaExplanationRepresentation): void;
-export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_FormulaExplanationRepresentation_FormulaExplanationRepresentation>, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_FormulaExplanationRepresentation_FormulaExplanationRepresentation>): $64$luvio_engine_FulfilledSnapshot<types_FormulaExplanationRepresentation_FormulaExplanationRepresentation, {}> | $64$luvio_engine_StaleSnapshot<types_FormulaExplanationRepresentation_FormulaExplanationRepresentation, {}> | $64$luvio_engine_PendingSnapshot<types_FormulaExplanationRepresentation_FormulaExplanationRepresentation, any>;
-export declare function ingestError(luvio: $64$luvio_engine_Luvio, params: ResourceRequestConfig, error: $64$luvio_engine_ErrorResponse, snapshotRefresh?: $64$luvio_engine_SnapshotRefresh<types_FormulaExplanationRepresentation_FormulaExplanationRepresentation>): $64$luvio_engine_ErrorSnapshot;
+export declare function ingestSuccess(luvio: $64$luvio_engine_Luvio, resourceParams: ResourceRequestConfig, response: $64$luvio_engine_FetchResponse<types_FormulaExplanationRepresentation_FormulaExplanationRepresentation>): $64$luvio_engine_FulfilledSnapshot<types_FormulaExplanationRepresentation_FormulaExplanationRepresentation, {}> | $64$luvio_engine_StaleSnapshot<types_FormulaExplanationRepresentation_FormulaExplanationRepresentation, {}> | $64$luvio_engine_PendingSnapshot<types_FormulaExplanationRepresentation_FormulaExplanationRepresentation, any>;
 export declare function createResourceRequest(config: ResourceRequestConfig): $64$luvio_engine_ResourceRequest;
 export default createResourceRequest;

package/dist/es/es2018/types/src/generated/types/FormulaExplanationRepresentation.d.ts

@@ -1,8 +1,17 @@
-import { IngestPath as $64$luvio_engine_IngestPath, Luvio as $64$luvio_engine_Luvio, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata } from '@luvio/engine';
+import { KeyMetadata as $64$luvio_engine_KeyMetadata, NormalizedKeyMetadata as $64$luvio_engine_NormalizedKeyMetadata, Luvio as $64$luvio_engine_Luvio, IngestPath as $64$luvio_engine_IngestPath, Store as $64$luvio_engine_Store, FragmentSelection as $64$luvio_engine_FragmentSelection, ResourceIngest as $64$luvio_engine_ResourceIngest, DurableStoreKeyMetadataMap as $64$luvio_engine_DurableStoreKeyMetadataMap } from '@luvio/engine';
 export declare const TTL = 100;
-export declare const VERSION = "6cbd1c5cb74b9f1dee47794fd77fc37b";
+export declare const VERSION = "c06ad095a0c68e00a7cf4b94f01f937b";
 export declare function validate(obj: any, path?: string): TypeError | null;
 export declare const RepresentationType: string;
+export interface KeyParams extends $64$luvio_engine_KeyMetadata {
+    generationId: string;
+}
+export type FormulaExplanationRepresentationNormalizedKeyMetadata = KeyParams & $64$luvio_engine_NormalizedKeyMetadata;
+export type PartialFormulaExplanationRepresentationNormalizedKeyMetadata = Partial<KeyParams> & $64$luvio_engine_NormalizedKeyMetadata;
+export declare function keyBuilder(luvio: $64$luvio_engine_Luvio, config: KeyParams): string;
+export declare function keyBuilder_StructuredKey(luvio: $64$luvio_engine_Luvio, config: KeyParams): FormulaExplanationRepresentationNormalizedKeyMetadata;
+export declare function keyBuilderFromType(luvio: $64$luvio_engine_Luvio, object: FormulaExplanationRepresentation): string;
+export declare function keyBuilderFromType_StructuredKey(luvio: $64$luvio_engine_Luvio, object: FormulaExplanationRepresentation): $64$luvio_engine_NormalizedKeyMetadata;
 export declare function normalize(input: FormulaExplanationRepresentation, existing: FormulaExplanationRepresentationNormalized, path: $64$luvio_engine_IngestPath, luvio: $64$luvio_engine_Luvio, store: $64$luvio_engine_Store, timestamp: number): FormulaExplanationRepresentationNormalized;
 export declare const select: () => $64$luvio_engine_FragmentSelection;
 export declare function equals(existing: FormulaExplanationRepresentationNormalized, incoming: FormulaExplanationRepresentationNormalized): boolean;
@@ -12,7 +21,7 @@ export declare function getTypeCacheKeys(rootKeySet: $64$luvio_engine_DurableSto
  * Formula Explanation
  *
  * Keys:
- *    (none)
+ *    generationId (string): generationId
  */
 export interface FormulaExplanationRepresentationNormalized {
     /** Explanation of a formula */
@@ -24,7 +33,7 @@ export interface FormulaExplanationRepresentationNormalized {
  * Formula Explanation
  *
  * Keys:
- *    (none)
+ *    generationId (string): generationId
  */
 export interface FormulaExplanationRepresentation {
     explanation: string;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-adapters-platform-formula",
-    "version": "1.244.0",
+    "version": "1.246.0",
     "description": "APIs related to core Salesforce Formulas",
     "license": "SEE LICENSE IN LICENSE.txt",
     "main": "dist/es/es2018/platform-formula.js",
@@ -31,7 +31,7 @@
         "karan.jain@salesforce.com"
     ],
     "scripts": {
-        "build": "yarn build:raml && yarn build:services",
+        "build": "yarn build:services",
         "build:raml": "luvio generate src/raml/luvio.raml src/generated -p '../lds-compiler-plugins'",
         "build:services": "rollup --bundleConfigAsCjs --config rollup.config.js",
         "clean": "rm -rf dist sfdc src/generated",
@@ -50,9 +50,13 @@
         "targets": {
             "build": {
                 "outputs": [
-                    "packages/lds-adapters-platform-formula/dist",
-                    "packages/lds-adapters-platform-formula/sfdc",
-                    "packages/lds-adapters-platform-formula/src/generated"
+                    "{projectRoot}/dist",
+                    "{projectRoot}/sfdc"
+                ]
+            },
+            "build:raml": {
+                "outputs": [
+                    "{projectRoot}/src/generated"
                 ]
             }
         }

package/sfdc/index.js

@@ -12,9 +12,8 @@
  *  *******************************************************************************************
  */
 /* proxy-compat-disable */
-import { createInstrumentedAdapter, createLDSAdapter, createWireAdapterConstructor, createImperativeAdapter } from 'force/ldsBindings';
 import { withDefaultLuvio } from 'force/ldsEngine';
-import { serializeStructuredKey, ingestShape, deepFreeze, buildNetworkSnapshotCachePolicy as buildNetworkSnapshotCachePolicy$1, typeCheckConfig as typeCheckConfig$1, StoreKeyMap, createResourceParams as createResourceParams$1 } from 'force/luvioEngine';
+import { serializeStructuredKey, ingestShape, deepFreeze, StoreKeyMap, createResourceParams as createResourceParams$1, typeCheckConfig as typeCheckConfig$1 } from 'force/luvioEngine';
 
 const { hasOwnProperty: ObjectPrototypeHasOwnProperty } = Object.prototype;
 const { keys: ObjectKeys, create: ObjectCreate } = Object;
@@ -51,13 +50,6 @@ function untrustedIsObject(untrusted) {
 function areRequiredParametersPresent(config, configPropertyNames) {
     return configPropertyNames.parameters.required.every(req => req in config);
 }
-const snapshotRefreshOptions = {
-    overrides: {
-        headers: {
-            'Cache-Control': 'no-cache',
-        },
-    }
-};
 function generateParamConfigMetadata(name, required, resourceType, typeCheckShape, isArrayShape = false, coerceFn) {
     return {
         name,
@@ -89,7 +81,7 @@ function createLink(ref) {
 }
 
 const TTL = 100;
-const VERSION = "6cbd1c5cb74b9f1dee47794fd77fc37b";
+const VERSION = "c06ad095a0c68e00a7cf4b94f01f937b";
 function validate(obj, path = 'FormulaExplanationRepresentation') {
     const v_error = (() => {
         if (typeof obj !== 'object' || ArrayIsArray(obj) || obj === null) {
@@ -109,6 +101,15 @@ function validate(obj, path = 'FormulaExplanationRepresentation') {
     return v_error === undefined ? null : v_error;
 }
 const RepresentationType = 'FormulaExplanationRepresentation';
+function keyBuilder(luvio, config) {
+    return keyPrefix + '::' + RepresentationType + ':' + config.generationId;
+}
+function keyBuilderFromType(luvio, object) {
+    const keyParams = {
+        generationId: object.generationId
+    };
+    return keyBuilder(luvio, keyParams);
+}
 function normalize(input, existing, path, luvio, store, timestamp) {
     return input;
 }
@@ -149,14 +150,14 @@ const ingest = function FormulaExplanationRepresentationIngest(input, path, luvi
             throw validateError;
         }
     }
-    const key = path.fullPath;
+    const key = keyBuilderFromType(luvio, input);
     const ttlToUse = TTL;
     ingestShape(input, path, luvio, store, timestamp, ttlToUse, key, normalize, "Formula", VERSION, RepresentationType, equals);
     return createLink(key);
 };
 function getTypeCacheKeys(rootKeySet, luvio, input, fullPathFactory) {
     // root cache key (uses fullPathFactory if keyBuilderFromType isn't defined)
-    const rootKey = fullPathFactory();
+    const rootKey = keyBuilderFromType(luvio, input);
     rootKeySet.set(rootKey, {
         namespace: keyPrefix,
         representationName: RepresentationType,
@@ -167,21 +168,18 @@ function getTypeCacheKeys(rootKeySet, luvio, input, fullPathFactory) {
 function select(luvio, params) {
     return select$1();
 }
-function keyBuilder$1(luvio, params) {
-    return keyPrefix + '::FormulaExplanationRepresentation:(' + 'entityName:' + params.body.entityName + '::' + 'formula:' + params.body.formula + '::' + 'formulaType:' + params.body.formulaType + '::' + 'returnType:' + params.body.returnType + ')';
-}
 function getResponseCacheKeys(storeKeyMap, luvio, resourceParams, response) {
-    getTypeCacheKeys(storeKeyMap, luvio, response, () => keyBuilder$1(luvio, resourceParams));
+    getTypeCacheKeys(storeKeyMap, luvio, response);
 }
-function ingestSuccess(luvio, resourceParams, response, snapshotRefresh) {
+function ingestSuccess(luvio, resourceParams, response) {
     const { body } = response;
-    const key = keyBuilder$1(luvio, resourceParams);
+    const key = keyBuilderFromType(luvio, body);
     luvio.storeIngest(key, ingest, body);
     const snapshot = luvio.storeLookup({
         recordId: key,
         node: select(),
         variables: {},
-    }, snapshotRefresh);
+    });
     if (process.env.NODE_ENV !== 'production') {
         if (snapshot.state !== 'Fulfilled') {
             throw new Error('Invalid network response. Expected resource response to result in Fulfilled snapshot');
@@ -190,18 +188,6 @@ function ingestSuccess(luvio, resourceParams, response, snapshotRefresh) {
     deepFreeze(snapshot.data);
     return snapshot;
 }
-function ingestError(luvio, params, error, snapshotRefresh) {
-    const key = keyBuilder$1(luvio, params);
-    const errorSnapshot = luvio.errorSnapshot(error, snapshotRefresh);
-    const storeMetadataParams = {
-        ttl: TTL,
-        namespace: keyPrefix,
-        version: VERSION,
-        representationName: RepresentationType
-    };
-    luvio.storeIngestError(key, errorSnapshot, storeMetadataParams);
-    return errorSnapshot;
-}
 function createResourceRequest(config) {
     const headers = {};
     return {
@@ -225,10 +211,6 @@ const getExplanation_ConfigPropertyMetadata = [
 ];
 const getExplanation_ConfigPropertyNames = /*#__PURE__*/ buildAdapterValidationConfig(adapterName, getExplanation_ConfigPropertyMetadata);
 const createResourceParams = /*#__PURE__*/ createResourceParams$1(getExplanation_ConfigPropertyMetadata);
-function keyBuilder(luvio, config) {
-    const resourceParams = createResourceParams(config);
-    return keyBuilder$1(luvio, resourceParams);
-}
 function typeCheckConfig(untrustedConfig) {
     const config = {};
     typeCheckConfig$1(untrustedConfig, config, getExplanation_ConfigPropertyMetadata);
@@ -247,84 +229,51 @@ function validateAdapterConfig(untrustedConfig, configPropertyNames) {
     }
     return config;
 }
-function adapterFragment(luvio, config) {
-    createResourceParams(config);
-    return select();
-}
-function onFetchResponseSuccess(luvio, config, resourceParams, response) {
-    const snapshot = ingestSuccess(luvio, resourceParams, response, {
-        config,
-        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
-    });
-    return luvio.storeBroadcast().then(() => snapshot);
-}
-function onFetchResponseError(luvio, config, resourceParams, response) {
-    const snapshot = ingestError(luvio, resourceParams, response, {
-        config,
-        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
-    });
-    return luvio.storeBroadcast().then(() => snapshot);
-}
 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), () => {
+        return luvio.handleSuccessResponse(() => {
+            const snapshot = ingestSuccess(luvio, resourceParams, response);
+            return luvio.storeBroadcast().then(() => snapshot);
+        }, () => {
             const cache = new StoreKeyMap();
             getResponseCacheKeys(cache, luvio, resourceParams, response.body);
             return cache;
         });
     }, (response) => {
-        return luvio.handleErrorResponse(() => onFetchResponseError(luvio, config, resourceParams, response));
+        deepFreeze(response);
+        throw response;
     });
 }
-function buildNetworkSnapshotCachePolicy(context, coercedAdapterRequestContext) {
-    return buildNetworkSnapshotCachePolicy$1(context, coercedAdapterRequestContext, buildNetworkSnapshot, 'get', false);
-}
-function buildCachedSnapshotCachePolicy(context, storeLookup) {
-    const { luvio, config } = context;
-    const selector = {
-        recordId: keyBuilder(luvio, config),
-        node: adapterFragment(luvio, config),
-        variables: {},
+const getExplanationAdapterFactory = (luvio) => {
+    return function getExplanation(untrustedConfig) {
+        const config = validateAdapterConfig(untrustedConfig, getExplanation_ConfigPropertyNames);
+        // Invalid or incomplete config
+        if (config === null) {
+            throw new Error('Invalid config for "getExplanation"');
+        }
+        return buildNetworkSnapshot(luvio, config);
     };
-    const cacheSnapshot = storeLookup(selector, {
-        config,
-        resolve: () => buildNetworkSnapshot(luvio, config, snapshotRefreshOptions)
-    });
-    return cacheSnapshot;
-}
-const getExplanationAdapterFactory = (luvio) => function Formula__getExplanation(untrustedConfig, requestContext) {
-    const config = validateAdapterConfig(untrustedConfig, getExplanation_ConfigPropertyNames);
-    // Invalid or incomplete config
-    if (config === null) {
-        return null;
-    }
-    return luvio.applyCachePolicy((requestContext || {}), { config, luvio }, // BuildSnapshotContext
-    buildCachedSnapshotCachePolicy, buildNetworkSnapshotCachePolicy);
 };
 
 let getExplanation;
-// Imperative GET Adapters
-let getExplanation_imperative;
-// Adapter Metadata
-const getExplanationMetadata = { apiFamily: 'Formula', name: 'getExplanation', ttl: 100 };
 function bindExportsTo(luvio) {
-    // LDS Adapters
-    const getExplanation_ldsAdapter = createInstrumentedAdapter(createLDSAdapter(luvio, 'getExplanation', getExplanationAdapterFactory), getExplanationMetadata);
+    function unwrapSnapshotData(factory) {
+        const adapter = factory(luvio);
+        return (config) => adapter(config).then(snapshot => snapshot.data);
+    }
     return {
-        getExplanation: createWireAdapterConstructor(luvio, getExplanation_ldsAdapter, getExplanationMetadata),
+        getExplanation: unwrapSnapshotData(getExplanationAdapterFactory),
         // Imperative GET Adapters
-        getExplanation_imperative: createImperativeAdapter(luvio, getExplanation_ldsAdapter, getExplanationMetadata)
     };
 }
 withDefaultLuvio((luvio) => {
     ({
         getExplanation,
-        getExplanation_imperative
     } = bindExportsTo(luvio));
 });
 
-export { getExplanation, getExplanation_imperative };
-// version: 1.244.0-4d142822f
+export { getExplanation };
+// version: 1.246.0-3f6b4cf3f

package/src/raml/luvio.raml

@@ -10,9 +10,10 @@ uses:
 types:
   FormulaExplanationRepresentation:
     (luvio.ttl): 100
+    (luvio.key):
+      generationId: generationId
 
 /connect/formula/einstein/explain:
   post:
     (luvio.adapter):
       name: getExplanation
-    (luvio.method): get