@veloceapps/sdk 8.0.0-11 → 8.0.0-111

package/esm2020/core/services/flow-state.service.mjs

@@ -0,0 +1,363 @@
+import { Inject, Injectable, Optional } from '@angular/core';
+import { ConfigurationProcessorsApiService, FlowStateApiService, QuoteApiService } from '@veloceapps/api';
+import { ToastService, ToastType } from '@veloceapps/components';
+import { ConfigurationContextMode, ConfigurationProcessorTypes, EntityUtil, isDefined, UITemplateType, UUID, } from '@veloceapps/core';
+import { assign, cloneDeep, flatten } from 'lodash';
+import { BehaviorSubject, combineLatest, filter, finalize, forkJoin, map, noop, of, skip, Subject, switchMap, takeUntil, tap, } from 'rxjs';
+import { FlowConfigurationService } from '../modules';
+import { FLOW_CUSTOMIZATION } from '../types/flow-customization.types';
+import { ContextService } from './context.service';
+import { FlowInfoService } from './flow-info.service';
+import { QuoteDraftService } from './quote-draft.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./context.service";
+import * as i2 from "./quote-draft.service";
+import * as i3 from "./flow-info.service";
+import * as i4 from "../modules";
+import * as i5 from "@veloceapps/api";
+import * as i6 from "@veloceapps/components";
+export class FlowStateService {
+    constructor(contextService, quoteDraftService, flowInfoService, flowConfiguration, processorsApiService, flowStateApiService, quoteApiService, toastService, customizationService) {
+        this.contextService = contextService;
+        this.quoteDraftService = quoteDraftService;
+        this.flowInfoService = flowInfoService;
+        this.flowConfiguration = flowConfiguration;
+        this.processorsApiService = processorsApiService;
+        this.flowStateApiService = flowStateApiService;
+        this.quoteApiService = quoteApiService;
+        this.toastService = toastService;
+        this.customizationService = customizationService;
+        this.NOT_INITIALIZED = Symbol();
+        this.stateId$ = new BehaviorSubject(null);
+        this.processors = {};
+        this.subscriptions = {};
+        this.cleanup$ = new Subject();
+        /*
+          In stateless mode watch QuoteDraft changes and call executeRequest so that
+          all subscriptions get their updates according to updated QuoteDraft
+        */
+        this.isInitialized$()
+            .pipe(filter(Boolean), filter(() => !this.getFlowSafe().properties.stateful), switchMap(() => this.quoteDraftService.quoteDraft$), skip(1), switchMap(() => this.executeRequest$({})))
+            .subscribe();
+    }
+    init$() {
+        return this.initProcessors$().pipe(switchMap(() => {
+            if (this.getFlowSafe().properties.stateful) {
+                return this.initStateful$();
+            }
+            else {
+                return this.initStateless$();
+            }
+        }));
+    }
+    cleanup() {
+        Object.values(this.subscriptions).forEach(({ data$ }) => data$.complete());
+        this.subscriptions = {};
+        if (this.stateId$.value) {
+            this.flowStateApiService.cancel(this.stateId$.value).subscribe();
+            this.stateId$.next(null);
+        }
+        this.processors = {};
+        this.cleanup$.next();
+    }
+    isInitialized$() {
+        return combineLatest([this.stateId$, this.quoteDraftService.isInitialized$]).pipe(map(values => values.some(Boolean)));
+    }
+    isInitialized() {
+        return Boolean(this.stateId$.value) || this.quoteDraftService.isInitialized;
+    }
+    execute$(scope, exec) {
+        const request = this.execToRequest(scope, exec);
+        return this.executeRequest$(request).pipe(map(result => {
+            // Keep only requested results
+            const actualSelectors = Object.entries(result.selectors).reduce((trunk, [requestId, result]) => {
+                if (exec.selectors?.[requestId]) {
+                    trunk[requestId] = result;
+                }
+                return trunk;
+            }, {});
+            return actualSelectors;
+        }));
+    }
+    dispatch$(scope, action, inputData) {
+        const exec = {
+            actions: [{ name: action, inputData }],
+        };
+        const request = this.execToRequest(scope, exec);
+        return this.executeRequest$(request).pipe(map(noop));
+    }
+    select$(scope, selectorName, inputData) {
+        const requestId = UUID.UUID();
+        const request = this.execToRequest(scope, {
+            selectors: {
+                [requestId]: {
+                    name: selectorName,
+                    inputData,
+                },
+            },
+        });
+        return this.executeRequest$(request).pipe(map(response => response.selectors[requestId]));
+    }
+    subscribe$(scope, selectorName, inputData, options) {
+        const inputDataHash = UUID.hex(JSON.stringify(inputData)).slice(0, 8);
+        const requestId = `${scope}/${selectorName}/${inputDataHash}`;
+        if (!this.subscriptions[requestId]) {
+            const request = this.execToRequest(scope, {
+                selectors: {
+                    [requestId]: {
+                        name: selectorName,
+                        inputData,
+                    },
+                },
+            });
+            this.subscriptions[requestId] = {
+                request,
+                data$: new BehaviorSubject(this.NOT_INITIALIZED),
+            };
+            if (!options?.cold) {
+                this.executeRequest$(request).subscribe();
+            }
+        }
+        return this.subscriptions[requestId].data$.pipe(filter(data => data != this.NOT_INITIALIZED), map(data => data), finalize(() => {
+            if (!this.subscriptions[requestId].data$.observed) {
+                delete this.subscriptions[requestId];
+            }
+        }));
+    }
+    save$() {
+        if (this.getFlowSafe().properties.stateful) {
+            if (this.stateId$.value) {
+                return this.flowStateApiService.save(this.stateId$.value);
+            }
+        }
+        else {
+            const quoteDraft = this.quoteDraftService.quoteDraftForActivePriceList;
+            if (quoteDraft) {
+                return this.quoteApiService.upsertQuote(quoteDraft).pipe(map(noop));
+            }
+        }
+        return of(undefined);
+    }
+    submit$() {
+        if (this.getFlowSafe().properties.stateful) {
+            if (this.stateId$.value) {
+                return this.flowStateApiService.submit(this.stateId$.value);
+            }
+        }
+        else {
+            const quoteDraft = this.quoteDraftService.quoteDraftForActivePriceList;
+            if (quoteDraft) {
+                return this.quoteApiService.submitQuote(quoteDraft).pipe(map(noop));
+            }
+        }
+        return of(undefined);
+    }
+    getOwnerIdByScope(scope) {
+        const ownerId = this.flowInfoService.templates[scope]?.id;
+        if (!ownerId) {
+            throw `OwnerId is not found for scope ${scope}`;
+        }
+        return ownerId;
+    }
+    getScopeByOwnerId(id) {
+        for (const template of Object.values(this.flowInfoService.templates)) {
+            if (template.id === id) {
+                return template.type;
+            }
+        }
+        return;
+    }
+    execToRequest(scope, exec) {
+        const ownerId = this.getOwnerIdByScope(scope);
+        return {
+            actions: exec.actions?.map(action => ({ apiName: action.name, ownerId, inputData: action.inputData ?? {} })),
+            selectors: exec.selectors &&
+                Object.entries(exec.selectors).reduce((trunk, [key, selector]) => ({
+                    ...trunk,
+                    [key]: { apiName: selector.name, ownerId, inputData: selector.inputData ?? {} },
+                }), {}),
+        };
+    }
+    executeRequest$(request) {
+        const fullRequest = cloneDeep(request);
+        if (fullRequest.actions?.length) {
+            for (const subscription of Object.values(this.subscriptions)) {
+                fullRequest.selectors = assign(fullRequest.selectors, subscription.request.selectors);
+            }
+        }
+        const execution$ = this.getFlowSafe().properties.stateful
+            ? this.executeStateful$(fullRequest)
+            : this.executeStateless$(fullRequest);
+        return execution$.pipe(tap(result => this.handleSelectorsResponse(result.selectors)));
+    }
+    handleSelectorsResponse(selectors) {
+        Object.entries(selectors).forEach(([requestId, selectorResult]) => {
+            if (!selectorResult.success) {
+                this.toastService.add({ severity: ToastType.error, summary: selectorResult.errorMessage });
+            }
+            const subscription$ = this.subscriptions[requestId]?.data$;
+            if (subscription$) {
+                subscription$.next(selectorResult);
+            }
+        });
+    }
+    initStateful$() {
+        // Subscriptions
+        this.subscribe$(UITemplateType.FLOW_ENGINE, 'GET_CONTEXT', null, { cold: true })
+            .pipe(tap(response => {
+            if (response.success) {
+                this.contextService.update(response.result);
+            }
+        }), takeUntil(this.cleanup$))
+            .subscribe();
+        const processorsList = flatten(Object.values(this.processors).map(ownerMap => Object.values(ownerMap ?? {})));
+        const processors = processorsList.length ? processorsList : undefined;
+        const selectors = Object.values(this.subscriptions)
+            .map(({ request }) => request.selectors)
+            .filter(isDefined)
+            .reduce((trunk, selectors) => ({ ...trunk, ...selectors }), {});
+        return this.flowStateApiService
+            .init({
+            quoteId: this.contextService.resolve().headerId,
+            params: this.flowInfoService.params ?? {},
+            actionsOverride: processors?.filter(processor => processor.type === ConfigurationProcessorTypes.ACTION),
+            selectorsOverride: processors?.filter(processor => processor.type === ConfigurationProcessorTypes.SELECTOR),
+            selectors,
+        })
+            .pipe(map(({ stateId, selectors }) => {
+            this.handleSelectorsResponse(selectors);
+            this.stateId$.next(stateId);
+        }));
+    }
+    executeStateful$(request) {
+        if (!this.stateId$.value) {
+            throw 'Stateful session is not initialized';
+        }
+        return this.flowStateApiService
+            .execute(this.stateId$.value, request)
+            .pipe(tap(response => this.stateId$.next(response.stateId)));
+    }
+    initStateless$() {
+        const { headerId } = this.contextService.resolve();
+        const stateInit$ = this.quoteDraftService
+            .init(headerId, this.flowInfoService.params ?? {})
+            .pipe(switchMap(() => this.calculate$()));
+        return forkJoin([this.initProcessors$(), stateInit$]).pipe(tap(() => this.quoteDraftService.finalizeInit()), map(noop));
+    }
+    calculate$() {
+        const flowState = this.quoteDraftService.quoteDraft;
+        if (!flowState) {
+            return of(undefined);
+        }
+        /*
+          Don't execute procedures when:
+            * Initializing a standalone product configuration UI, as procedure is execute in /price call
+            * Initializing an empty account (account with no assets)
+        */
+        const isEmptyAccountMode = this.contextService.mode === ConfigurationContextMode.ACCOUNT && !this.quoteDraftService.hasProducts;
+        if (this.quoteDraftService.isStandalone || isEmptyAccountMode) {
+            return of(undefined);
+        }
+        return this.flowConfiguration.calculate$(flowState);
+    }
+    executeStateless$(request) {
+        return of(undefined).pipe(switchMap(() => {
+            if (!this.quoteDraftService.quoteDraft || !request.actions?.length) {
+                return of(undefined);
+            }
+            let flowState = this.quoteDraftService.quoteDraft;
+            request.actions.forEach(action => {
+                flowState = this.executeActionScript(flowState, action) ?? flowState;
+            });
+            this.quoteDraftService.updateQuoteDraft(flowState);
+            return this.calculate$();
+        }), map(() => {
+            if (!this.quoteDraftService.quoteDraft) {
+                throw 'QuoteDraft is not initialized';
+            }
+            const flowState = this.quoteDraftService.quoteDraft;
+            const executionResult = EntityUtil.entries(request.selectors ?? {}).reduce((result, [key, selector]) => {
+                try {
+                    result.selectors[key] = {
+                        success: true,
+                        result: this.executeSelectorScript(flowState, selector),
+                    };
+                }
+                catch (e) {
+                    result.selectors[key] = {
+                        success: false,
+                        errorMessage: String(e),
+                    };
+                }
+                return result;
+            }, { stateId: '', selectors: {} });
+            return executionResult;
+        }));
+    }
+    getFlowSafe() {
+        if (!this.flowInfoService.flow) {
+            throw 'Flow is not defined';
+        }
+        return this.flowInfoService.flow;
+    }
+    initProcessors$() {
+        const hasOverrides = Boolean(this.customizationService?.getTemplateConfigurationProcessors);
+        const flow = this.getFlowSafe();
+        if (flow.properties.stateful && !hasOverrides) {
+            // Skip initialization as backend will take processors from SF
+            return of(undefined);
+        }
+        const owners$ = Object.values(this.flowInfoService.templates)
+            .map(template => {
+            if (!template) {
+                return;
+            }
+            const localProcessors$ = this.customizationService?.getTemplateConfigurationProcessors?.(template.name) ?? of(null);
+            return localProcessors$.pipe(switchMap(processors => processors ? of(processors) : this.processorsApiService.fetchConfigurationProcessors$(template.id)), tap(processors => {
+                const processorsMap = processors.reduce((acc, p) => {
+                    acc[p.apiName] = p;
+                    return acc;
+                }, {});
+                this.processors[template.id] = processorsMap;
+            }));
+        })
+            .filter(isDefined);
+        return forkJoin(owners$).pipe(map(noop));
+    }
+    executeActionScript(request, executable) {
+        const script = this.processors[executable.ownerId]?.[executable.apiName]?.script;
+        if (!script) {
+            const scope = this.getScopeByOwnerId(executable.ownerId);
+            const scopeText = scope ? ` in ${scope}` : '';
+            throw `ConfigurationProcessor ${executable.apiName}${scopeText} not found`;
+        }
+        return this.executeProcessorScript(request, script, executable.inputData);
+    }
+    executeSelectorScript(request, executable) {
+        const script = this.processors[executable.ownerId]?.[executable.apiName]?.script;
+        if (!script) {
+            const scope = this.getScopeByOwnerId(executable.ownerId);
+            const scopeText = scope ? ` in ${scope}` : '';
+            throw `ConfigurationProcessor ${executable.apiName}${scopeText} not found`;
+        }
+        return this.executeProcessorScript(request, script, executable.inputData);
+    }
+    executeProcessorScript(request, script, inputData) {
+        return new Function(`${script}\nreturn transform;`)()({
+            request,
+            inputData: inputData,
+        });
+    }
+}
+FlowStateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowStateService, deps: [{ token: i1.ContextService }, { token: i2.QuoteDraftService }, { token: i3.FlowInfoService }, { token: i4.FlowConfigurationService }, { token: i5.ConfigurationProcessorsApiService }, { token: i5.FlowStateApiService }, { token: i5.QuoteApiService }, { token: i6.ToastService }, { token: FLOW_CUSTOMIZATION, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+FlowStateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowStateService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: FlowStateService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.ContextService }, { type: i2.QuoteDraftService }, { type: i3.FlowInfoService }, { type: i4.FlowConfigurationService }, { type: i5.ConfigurationProcessorsApiService }, { type: i5.FlowStateApiService }, { type: i5.QuoteApiService }, { type: i6.ToastService }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [FLOW_CUSTOMIZATION]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flow-state.service.js","sourceRoot":"","sources":["../../../../../../libs/sdk/core/services/flow-state.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core';\nimport { ConfigurationProcessorsApiService, FlowStateApiService, QuoteApiService } from '@veloceapps/api';\nimport { ToastService, ToastType } from '@veloceapps/components';\nimport {\n  ConfigurationContext,\n  ConfigurationContextMode,\n  ConfigurationProcessor,\n  ConfigurationProcessorTypes,\n  EntityUtil,\n  Flow,\n  FlowState,\n  FlowStateExecutableDTO,\n  FlowStateExecutionRequest,\n  FlowStateExecutionRequestDTO,\n  FlowStateExecutionResult,\n  FlowStateSelectorResponse,\n  isDefined,\n  UITemplateType,\n  UUID,\n} from '@veloceapps/core';\nimport { assign, cloneDeep, flatten } from 'lodash';\nimport {\n  BehaviorSubject,\n  combineLatest,\n  filter,\n  finalize,\n  forkJoin,\n  map,\n  noop,\n  Observable,\n  of,\n  skip,\n  Subject,\n  switchMap,\n  takeUntil,\n  tap,\n} from 'rxjs';\nimport { FlowConfigurationService } from '../modules';\nimport { FlowCustomization, FLOW_CUSTOMIZATION } from '../types/flow-customization.types';\nimport { FlowStateSubscriptionOptions } from '../types/flow-state.types';\nimport { ContextService } from './context.service';\nimport { FlowInfoService } from './flow-info.service';\nimport { QuoteDraftService } from './quote-draft.service';\n\ntype ProcessorsMap = Partial<{\n  [ownerId: string]: {\n    [apiName: string]: ConfigurationProcessor;\n  };\n}>;\n\ntype Subscription = {\n  request: FlowStateExecutionRequestDTO;\n  data$: BehaviorSubject<unknown>;\n};\n\n@Injectable({ providedIn: 'root' })\nexport class FlowStateService {\n  private readonly NOT_INITIALIZED = Symbol();\n\n  private stateId$ = new BehaviorSubject<string | null>(null);\n  private processors: ProcessorsMap = {};\n  private subscriptions: Record<string, Subscription> = {};\n  private cleanup$ = new Subject<void>();\n\n  constructor(\n    private contextService: ContextService,\n    private quoteDraftService: QuoteDraftService,\n    private flowInfoService: FlowInfoService,\n    private flowConfiguration: FlowConfigurationService,\n    private processorsApiService: ConfigurationProcessorsApiService,\n    private flowStateApiService: FlowStateApiService,\n    private quoteApiService: QuoteApiService,\n    private toastService: ToastService,\n    @Optional() @Inject(FLOW_CUSTOMIZATION) private customizationService?: FlowCustomization,\n  ) {\n    /*\n      In stateless mode watch QuoteDraft changes and call executeRequest so that\n      all subscriptions get their updates according to updated QuoteDraft\n    */\n    this.isInitialized$()\n      .pipe(\n        filter(Boolean),\n        filter(() => !this.getFlowSafe().properties.stateful),\n        switchMap(() => this.quoteDraftService.quoteDraft$),\n        skip(1),\n        switchMap(() => this.executeRequest$({})),\n      )\n      .subscribe();\n  }\n\n  public init$(): Observable<void> {\n    return this.initProcessors$().pipe(\n      switchMap(() => {\n        if (this.getFlowSafe().properties.stateful) {\n          return this.initStateful$();\n        } else {\n          return this.initStateless$();\n        }\n      }),\n    );\n  }\n\n  public cleanup(): void {\n    Object.values(this.subscriptions).forEach(({ data$ }) => data$.complete());\n    this.subscriptions = {};\n\n    if (this.stateId$.value) {\n      this.flowStateApiService.cancel(this.stateId$.value).subscribe();\n      this.stateId$.next(null);\n    }\n\n    this.processors = {};\n    this.cleanup$.next();\n  }\n\n  public isInitialized$(): Observable<boolean> {\n    return combineLatest([this.stateId$, this.quoteDraftService.isInitialized$]).pipe(\n      map(values => values.some(Boolean)),\n    );\n  }\n\n  public isInitialized(): boolean {\n    return Boolean(this.stateId$.value) || this.quoteDraftService.isInitialized;\n  }\n\n  public execute$(\n    scope: UITemplateType,\n    exec: FlowStateExecutionRequest,\n  ): Observable<FlowStateExecutionResult['selectors']> {\n    const request = this.execToRequest(scope, exec);\n\n    return this.executeRequest$(request).pipe(\n      map(result => {\n        // Keep only requested results\n        const actualSelectors = Object.entries(result.selectors).reduce(\n          (trunk: Record<string, FlowStateSelectorResponse>, [requestId, result]) => {\n            if (exec.selectors?.[requestId]) {\n              trunk[requestId] = result;\n            }\n            return trunk;\n          },\n          {},\n        );\n\n        return actualSelectors;\n      }),\n    );\n  }\n\n  public dispatch$(scope: UITemplateType, action: string, inputData?: unknown): Observable<void> {\n    const exec: FlowStateExecutionRequest = {\n      actions: [{ name: action, inputData }],\n    };\n    const request = this.execToRequest(scope, exec);\n\n    return this.executeRequest$(request).pipe(map(noop));\n  }\n\n  public select$<Response = unknown>(\n    scope: UITemplateType,\n    selectorName: string,\n    inputData?: unknown,\n  ): Observable<FlowStateSelectorResponse<Response>> {\n    const requestId = UUID.UUID();\n    const request = this.execToRequest(scope, {\n      selectors: {\n        [requestId]: {\n          name: selectorName,\n          inputData,\n        },\n      },\n    });\n\n    return this.executeRequest$(request).pipe(\n      map(response => response.selectors[requestId] as FlowStateSelectorResponse<Response>),\n    );\n  }\n\n  public subscribe$<Response = unknown>(\n    scope: UITemplateType,\n    selectorName: string,\n    inputData?: unknown,\n    options?: FlowStateSubscriptionOptions,\n  ): Observable<FlowStateSelectorResponse<Response>> {\n    const inputDataHash = UUID.hex(JSON.stringify(inputData)).slice(0, 8);\n    const requestId = `${scope}/${selectorName}/${inputDataHash}`;\n\n    if (!this.subscriptions[requestId]) {\n      const request = this.execToRequest(scope, {\n        selectors: {\n          [requestId]: {\n            name: selectorName,\n            inputData,\n          },\n        },\n      });\n\n      this.subscriptions[requestId] = {\n        request,\n        data$: new BehaviorSubject<unknown>(this.NOT_INITIALIZED),\n      };\n\n      if (!options?.cold) {\n        this.executeRequest$(request).subscribe();\n      }\n    }\n\n    return this.subscriptions[requestId].data$.pipe(\n      filter(data => data != this.NOT_INITIALIZED),\n      map(data => data as FlowStateSelectorResponse<Response>),\n      finalize(() => {\n        if (!this.subscriptions[requestId].data$.observed) {\n          delete this.subscriptions[requestId];\n        }\n      }),\n    );\n  }\n\n  public save$(): Observable<void> {\n    if (this.getFlowSafe().properties.stateful) {\n      if (this.stateId$.value) {\n        return this.flowStateApiService.save(this.stateId$.value);\n      }\n    } else {\n      const quoteDraft = this.quoteDraftService.quoteDraftForActivePriceList;\n      if (quoteDraft) {\n        return this.quoteApiService.upsertQuote(quoteDraft).pipe(map(noop));\n      }\n    }\n\n    return of(undefined);\n  }\n\n  public submit$(): Observable<void> {\n    if (this.getFlowSafe().properties.stateful) {\n      if (this.stateId$.value) {\n        return this.flowStateApiService.submit(this.stateId$.value);\n      }\n    } else {\n      const quoteDraft = this.quoteDraftService.quoteDraftForActivePriceList;\n      if (quoteDraft) {\n        return this.quoteApiService.submitQuote(quoteDraft).pipe(map(noop));\n      }\n    }\n\n    return of(undefined);\n  }\n\n  private getOwnerIdByScope(scope: UITemplateType): string {\n    const ownerId = this.flowInfoService.templates[scope]?.id;\n    if (!ownerId) {\n      throw `OwnerId is not found for scope ${scope}`;\n    }\n\n    return ownerId;\n  }\n\n  private getScopeByOwnerId(id: string): UITemplateType | undefined {\n    for (const template of Object.values(this.flowInfoService.templates)) {\n      if (template.id === id) {\n        return template.type;\n      }\n    }\n\n    return;\n  }\n\n  private execToRequest(scope: UITemplateType, exec: FlowStateExecutionRequest): FlowStateExecutionRequestDTO {\n    const ownerId = this.getOwnerIdByScope(scope);\n\n    return {\n      actions: exec.actions?.map(action => ({ apiName: action.name, ownerId, inputData: action.inputData ?? {} })),\n      selectors:\n        exec.selectors &&\n        Object.entries(exec.selectors).reduce(\n          (trunk: Record<string, FlowStateExecutableDTO>, [key, selector]) => ({\n            ...trunk,\n            [key]: { apiName: selector.name, ownerId, inputData: selector.inputData ?? {} },\n          }),\n          {},\n        ),\n    };\n  }\n\n  private executeRequest$(request: FlowStateExecutionRequestDTO): Observable<FlowStateExecutionResult> {\n    const fullRequest = cloneDeep(request);\n    if (fullRequest.actions?.length) {\n      for (const subscription of Object.values(this.subscriptions)) {\n        fullRequest.selectors = assign(fullRequest.selectors, subscription.request.selectors);\n      }\n    }\n\n    const execution$ = this.getFlowSafe().properties.stateful\n      ? this.executeStateful$(fullRequest)\n      : this.executeStateless$(fullRequest);\n\n    return execution$.pipe(tap(result => this.handleSelectorsResponse(result.selectors)));\n  }\n\n  private handleSelectorsResponse(selectors: Record<string, FlowStateSelectorResponse<unknown>>): void {\n    Object.entries(selectors).forEach(([requestId, selectorResult]) => {\n      if (!selectorResult.success) {\n        this.toastService.add({ severity: ToastType.error, summary: selectorResult.errorMessage });\n      }\n\n      const subscription$ = this.subscriptions[requestId]?.data$;\n      if (subscription$) {\n        subscription$.next(selectorResult);\n      }\n    });\n  }\n\n  private initStateful$(): Observable<void> {\n    // Subscriptions\n    this.subscribe$<ConfigurationContext>(UITemplateType.FLOW_ENGINE, 'GET_CONTEXT', null, { cold: true })\n      .pipe(\n        tap(response => {\n          if (response.success) {\n            this.contextService.update(response.result);\n          }\n        }),\n        takeUntil(this.cleanup$),\n      )\n      .subscribe();\n\n    const processorsList = flatten(Object.values(this.processors).map(ownerMap => Object.values(ownerMap ?? {})));\n    const processors = processorsList.length ? processorsList : undefined;\n    const selectors = Object.values(this.subscriptions)\n      .map(({ request }) => request.selectors)\n      .filter(isDefined)\n      .reduce((trunk, selectors) => ({ ...trunk, ...selectors }), {});\n\n    return this.flowStateApiService\n      .init({\n        quoteId: this.contextService.resolve().headerId,\n        params: this.flowInfoService.params ?? {},\n        actionsOverride: processors?.filter(processor => processor.type === ConfigurationProcessorTypes.ACTION),\n        selectorsOverride: processors?.filter(processor => processor.type === ConfigurationProcessorTypes.SELECTOR),\n        selectors,\n      })\n      .pipe(\n        map(({ stateId, selectors }) => {\n          this.handleSelectorsResponse(selectors);\n          this.stateId$.next(stateId);\n        }),\n      );\n  }\n\n  private executeStateful$(request: FlowStateExecutionRequestDTO): Observable<FlowStateExecutionResult> {\n    if (!this.stateId$.value) {\n      throw 'Stateful session is not initialized';\n    }\n\n    return this.flowStateApiService\n      .execute(this.stateId$.value, request)\n      .pipe(tap(response => this.stateId$.next(response.stateId)));\n  }\n\n  private initStateless$(): Observable<void> {\n    const { headerId } = this.contextService.resolve();\n\n    const stateInit$ = this.quoteDraftService\n      .init(headerId, this.flowInfoService.params ?? {})\n      .pipe(switchMap(() => this.calculate$()));\n\n    return forkJoin([this.initProcessors$(), stateInit$]).pipe(\n      tap(() => this.quoteDraftService.finalizeInit()),\n      map(noop),\n    );\n  }\n\n  private calculate$(): Observable<void> {\n    const flowState = this.quoteDraftService.quoteDraft;\n    if (!flowState) {\n      return of(undefined);\n    }\n\n    /*\n      Don't execute procedures when:\n        * Initializing a standalone product configuration UI, as procedure is execute in /price call\n        * Initializing an empty account (account with no assets)\n    */\n    const isEmptyAccountMode =\n      this.contextService.mode === ConfigurationContextMode.ACCOUNT && !this.quoteDraftService.hasProducts;\n\n    if (this.quoteDraftService.isStandalone || isEmptyAccountMode) {\n      return of(undefined);\n    }\n\n    return this.flowConfiguration.calculate$(flowState);\n  }\n\n  private executeStateless$(request: FlowStateExecutionRequestDTO): Observable<FlowStateExecutionResult> {\n    return of(undefined).pipe(\n      switchMap(() => {\n        if (!this.quoteDraftService.quoteDraft || !request.actions?.length) {\n          return of(undefined);\n        }\n\n        let flowState = this.quoteDraftService.quoteDraft;\n        request.actions.forEach(action => {\n          flowState = this.executeActionScript(flowState, action) ?? flowState;\n        });\n\n        this.quoteDraftService.updateQuoteDraft(flowState);\n        return this.calculate$();\n      }),\n      map(() => {\n        if (!this.quoteDraftService.quoteDraft) {\n          throw 'QuoteDraft is not initialized';\n        }\n\n        const flowState = this.quoteDraftService.quoteDraft;\n        const executionResult = EntityUtil.entries(request.selectors ?? {}).reduce(\n          (result: FlowStateExecutionResult, [key, selector]) => {\n            try {\n              result.selectors[key] = {\n                success: true,\n                result: this.executeSelectorScript(flowState, selector),\n              };\n            } catch (e) {\n              result.selectors[key] = {\n                success: false,\n                errorMessage: String(e),\n              };\n            }\n\n            return result;\n          },\n          { stateId: '', selectors: {} },\n        );\n\n        return executionResult;\n      }),\n    );\n  }\n\n  private getFlowSafe(): Flow {\n    if (!this.flowInfoService.flow) {\n      throw 'Flow is not defined';\n    }\n\n    return this.flowInfoService.flow;\n  }\n\n  private initProcessors$(): Observable<void> {\n    const hasOverrides = Boolean(this.customizationService?.getTemplateConfigurationProcessors);\n    const flow = this.getFlowSafe();\n\n    if (flow.properties.stateful && !hasOverrides) {\n      // Skip initialization as backend will take processors from SF\n      return of(undefined);\n    }\n\n    const owners$ = Object.values(this.flowInfoService.templates)\n      .map(template => {\n        if (!template) {\n          return;\n        }\n\n        const localProcessors$ =\n          this.customizationService?.getTemplateConfigurationProcessors?.(template.name) ?? of(null);\n\n        return localProcessors$.pipe(\n          switchMap(processors =>\n            processors ? of(processors) : this.processorsApiService.fetchConfigurationProcessors$(template.id),\n          ),\n          tap(processors => {\n            const processorsMap = processors.reduce((acc: Record<string, ConfigurationProcessor>, p) => {\n              acc[p.apiName] = p;\n              return acc;\n            }, {});\n\n            this.processors[template.id] = processorsMap;\n          }),\n        );\n      })\n      .filter(isDefined);\n\n    return forkJoin(owners$).pipe(map(noop));\n  }\n\n  private executeActionScript(request: FlowState, executable: FlowStateExecutableDTO): FlowState | null {\n    const script = this.processors[executable.ownerId]?.[executable.apiName]?.script;\n\n    if (!script) {\n      const scope = this.getScopeByOwnerId(executable.ownerId);\n      const scopeText = scope ? ` in ${scope}` : '';\n      throw `ConfigurationProcessor ${executable.apiName}${scopeText} not found`;\n    }\n\n    return this.executeProcessorScript(request, script, executable.inputData) as FlowState;\n  }\n\n  private executeSelectorScript(request: FlowState, executable: FlowStateExecutableDTO): unknown {\n    const script = this.processors[executable.ownerId]?.[executable.apiName]?.script;\n\n    if (!script) {\n      const scope = this.getScopeByOwnerId(executable.ownerId);\n      const scopeText = scope ? ` in ${scope}` : '';\n      throw `ConfigurationProcessor ${executable.apiName}${scopeText} not found`;\n    }\n\n    return this.executeProcessorScript(request, script, executable.inputData);\n  }\n\n  private executeProcessorScript(request: FlowState, script: string, inputData: unknown): unknown {\n    return new Function(`${script}\\nreturn transform;`)()({\n      request,\n      inputData: inputData,\n    });\n  }\n}\n"]}

package/esm2020/core/services/index.mjs

@@ -1,6 +1,9 @@
 export * from './context.service';
+export * from './flow-info.service';
+export * from './flow-state.service';
+export * from './integration.state';
 export * from './metric-calculation/metric-calculation.service';
 export * from './product-images.service';
 export * from './quote-draft.service';
 export * from './runtime-settings.service';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3Nkay9jb3JlL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxpREFBaUQsQ0FBQztBQUNoRSxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyw0QkFBNEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29udGV4dC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbWV0cmljLWNhbGN1bGF0aW9uL21ldHJpYy1jYWxjdWxhdGlvbi5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vcHJvZHVjdC1pbWFnZXMuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3F1b3RlLWRyYWZ0LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9ydW50aW1lLXNldHRpbmdzLnNlcnZpY2UnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL3Nkay9jb3JlL3NlcnZpY2VzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxpREFBaUQsQ0FBQztBQUNoRSxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyw0QkFBNEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29udGV4dC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vZmxvdy1pbmZvLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9mbG93LXN0YXRlLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9pbnRlZ3JhdGlvbi5zdGF0ZSc7XG5leHBvcnQgKiBmcm9tICcuL21ldHJpYy1jYWxjdWxhdGlvbi9tZXRyaWMtY2FsY3VsYXRpb24uc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3Byb2R1Y3QtaW1hZ2VzLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9xdW90ZS1kcmFmdC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vcnVudGltZS1zZXR0aW5ncy5zZXJ2aWNlJztcbiJdfQ==

package/esm2020/core/services/integration.state.mjs

@@ -0,0 +1,37 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, filter, map, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class IntegrationState {
+    constructor() {
+        this.stateSubj$ = new BehaviorSubject({});
+        this.action$ = new Subject();
+    }
+    get state$() {
+        return this.stateSubj$.asObservable();
+    }
+    get state() {
+        return this.stateSubj$.getValue();
+    }
+    patchState(update) {
+        this.stateSubj$.next({ ...this.stateSubj$.getValue(), ...update });
+    }
+    dispatch(action) {
+        this.action$.next(action);
+    }
+    listen$(actionType) {
+        return this.action$.pipe(filter(action => action.type === actionType), map(action => action.payload));
+    }
+    listenAll$() {
+        return this.action$.asObservable();
+    }
+    clear() {
+        this.stateSubj$.next({});
+    }
+}
+IntegrationState.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: IntegrationState, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+IntegrationState.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: IntegrationState, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: IntegrationState, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/services/metric-calculation/metric-calculation.service.mjs

@@ -76,9 +76,9 @@ export class MetricsCalculationService {
         return this.activeMetricRules.find(metricRule => metricRule.metrics.find(metric => metric.totalName === name));
     }
 }
-MetricsCalculationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: MetricsCalculationService, deps: [{ token: i1.QuoteDraftService }, { token: i2.FlowConfigurationService }, { token: i3.ConfigurationSettingsApiService }], target: i0.ɵɵFactoryTarget.Injectable });
-MetricsCalculationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: MetricsCalculationService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: MetricsCalculationService, decorators: [{
+MetricsCalculationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: MetricsCalculationService, deps: [{ token: i1.QuoteDraftService }, { token: i2.FlowConfigurationService }, { token: i3.ConfigurationSettingsApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+MetricsCalculationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: MetricsCalculationService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: MetricsCalculationService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return [{ type: i1.QuoteDraftService }, { type: i2.FlowConfigurationService }, { type: i3.ConfigurationSettingsApiService }]; } });

package/esm2020/core/services/product-images.service.mjs

@@ -22,9 +22,9 @@ export class ProductImagesService {
             .subscribe();
     }
 }
-ProductImagesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ProductImagesService, deps: [{ token: i1.ProductApiService }], target: i0.ɵɵFactoryTarget.Injectable });
-ProductImagesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ProductImagesService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.8", ngImport: i0, type: ProductImagesService, decorators: [{
+ProductImagesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ProductImagesService, deps: [{ token: i1.ProductApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+ProductImagesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ProductImagesService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ProductImagesService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }], ctorParameters: function () { return [{ type: i1.ProductApiService }]; } });