@wise/dynamic-flow-client 5.30.1 → 5.30.2-experimental-949e5e5

package/build/domain/features/collection/getPerformCollectionQuery.test.js

@@ -1,215 +0,0 @@
-import { waitFor } from '@testing-library/react';
-import { respondWith } from '../../../test-utils';
-import { getPerformCollectionQuery } from './getPerformCollectionQuery';
-describe('getPerformCollectionQuery returns a function which', () => {
-    describe('makes a request with the provided config', () => {
-        it('includes the body property in POST requests', () => {
-            const httpClient = vi.fn().mockResolvedValue(respondWith({ sections: [] }));
-            const performCollectionQuery = getPerformCollectionQuery(httpClient, { url: '/abcd', method: 'POST', body: { currency: 'EUR' } }, vi.fn());
-            void performCollectionQuery({
-                searchParam: 'query',
-                signal: new AbortController().signal,
-                query: 'bob',
-            });
-            expect(httpClient).toHaveBeenCalledWith('/abcd', expect.objectContaining({
-                body: JSON.stringify({ currency: 'EUR', query: 'bob' }),
-            }));
-        });
-        it('ignores the body property in GET requests', () => {
-            const httpClient = vi.fn().mockResolvedValue(respondWith({ sections: [] }));
-            const performCollectionQuery = getPerformCollectionQuery(httpClient, { url: '/abcd', method: 'GET', body: { currency: 'EUR' } }, vi.fn());
-            void performCollectionQuery({
-                searchParam: 'query',
-                signal: new AbortController().signal,
-                query: 'bob',
-            });
-            expect(httpClient).toHaveBeenCalledWith('/abcd?query=bob', expect.anything());
-        });
-        describe('when the provided URL contains query parameters', () => {
-            it('retains those when generated the new URL when the method is GET', () => {
-                const httpClient = vi.fn().mockResolvedValue(respondWith({ sections: [] }));
-                const performCollectionQuery = getPerformCollectionQuery(httpClient, {
-                    url: '/abcd?name=bob',
-                    method: 'GET',
-                }, vi.fn());
-                void performCollectionQuery({
-                    searchParam: 'query',
-                    query: 'dave',
-                    signal: new AbortController().signal,
-                });
-                expect(httpClient).toHaveBeenCalledWith('/abcd?name=bob&query=dave', expect.anything());
-            });
-            it('retains those when generated the new URL when the method is POST', () => {
-                const httpClient = vi.fn().mockResolvedValue(respondWith({ sections: [] }));
-                const performCollectionQuery = getPerformCollectionQuery(httpClient, {
-                    url: '/abcd?name=bob',
-                    method: 'POST',
-                }, vi.fn());
-                void performCollectionQuery({
-                    searchParam: 'query',
-                    query: 'dave',
-                    signal: new AbortController().signal,
-                });
-                expect(httpClient).toHaveBeenCalledWith('/abcd?name=bob', expect.objectContaining({
-                    body: JSON.stringify({ query: 'dave' }),
-                }));
-            });
-        });
-        describe('when a filter is a select', () => {
-            describe('when the method is GET', () => {
-                it('encodes the FIRST value as a query param', () => {
-                    const httpClient = vi.fn().mockResolvedValue(respondWith({ sections: [] }));
-                    const performCollectionQuery = getPerformCollectionQuery(httpClient, {
-                        url: '/abcd',
-                        method: 'GET',
-                    }, vi.fn());
-                    void performCollectionQuery({
-                        searchParam: 'query',
-                        signal: new AbortController().signal,
-                        filters: [
-                            {
-                                type: 'select',
-                                param: 'key',
-                                options: [
-                                    {
-                                        value: 'a',
-                                        selected: true,
-                                        title: '',
-                                    },
-                                    {
-                                        value: 'b',
-                                        selected: true,
-                                        title: '',
-                                    },
-                                ],
-                            },
-                        ],
-                    });
-                    expect(httpClient).toHaveBeenCalledWith('/abcd?key=a', expect.anything());
-                });
-            });
-            describe('when the method is POST', () => {
-                it('encodes the FIRST value in the request body', () => {
-                    const httpClient = vi.fn().mockResolvedValue(respondWith({ sections: [] }));
-                    const performCollectionQuery = getPerformCollectionQuery(httpClient, { url: '/abcd', method: 'POST' }, vi.fn());
-                    void performCollectionQuery({
-                        searchParam: 'query',
-                        signal: new AbortController().signal,
-                        filters: [
-                            {
-                                type: 'select',
-                                param: 'key',
-                                options: [
-                                    {
-                                        value: 'a',
-                                        selected: true,
-                                        title: '',
-                                    },
-                                    {
-                                        value: 'b',
-                                        selected: true,
-                                        title: '',
-                                    },
-                                ],
-                            },
-                        ],
-                    });
-                    expect(httpClient).toHaveBeenCalledWith('/abcd', expect.objectContaining({
-                        body: JSON.stringify({ key: 'a' }),
-                    }));
-                });
-            });
-        });
-        describe('when a filter is multi select', () => {
-            describe('when the method is GET', () => {
-                it('encodes all values as query params', () => {
-                    const httpClient = vi.fn().mockResolvedValue(respondWith({ sections: [] }));
-                    const performCollectionQuery = getPerformCollectionQuery(httpClient, { url: '/abcd', method: 'GET' }, vi.fn());
-                    void performCollectionQuery({
-                        searchParam: 'query',
-                        signal: new AbortController().signal,
-                        filters: [
-                            {
-                                type: 'select',
-                                multiSelect: true,
-                                param: 'key',
-                                options: [
-                                    {
-                                        value: 'a',
-                                        selected: true,
-                                        title: '',
-                                    },
-                                    {
-                                        value: 'b',
-                                        selected: true,
-                                        title: '',
-                                    },
-                                ],
-                            },
-                        ],
-                    });
-                    expect(httpClient).toHaveBeenCalledWith('/abcd?key=a&key=b', expect.anything());
-                });
-            });
-            describe('when the method is POST', () => {
-                it('encodes all values in the request body', () => {
-                    const httpClient = vi.fn().mockResolvedValue(respondWith({ sections: [] }));
-                    const performCollectionQuery = getPerformCollectionQuery(httpClient, { url: '/abcd', method: 'POST' }, vi.fn());
-                    void performCollectionQuery({
-                        searchParam: 'query',
-                        signal: new AbortController().signal,
-                        filters: [
-                            {
-                                type: 'select',
-                                multiSelect: true,
-                                param: 'key',
-                                options: [
-                                    {
-                                        value: 'a',
-                                        selected: true,
-                                        title: '',
-                                    },
-                                    {
-                                        value: 'b',
-                                        selected: true,
-                                        title: '',
-                                    },
-                                ],
-                            },
-                        ],
-                    });
-                    expect(httpClient).toHaveBeenCalledWith('/abcd', expect.objectContaining({
-                        body: JSON.stringify({ key: ['a', 'b'] }),
-                    }));
-                });
-            });
-        });
-        describe('on successful response', () => {
-            it('returns mapped DL components', async () => {
-                const httpClient = vi.fn().mockResolvedValue(respondWith({ sections: [] }));
-                const mapper = vi.fn();
-                const performCollectionQuery = getPerformCollectionQuery(httpClient, { url: '/abcd', method: 'GET' }, mapper);
-                const t = performCollectionQuery({
-                    searchParam: 'query',
-                    signal: new AbortController().signal,
-                });
-                await expect(t).resolves.not.toThrow();
-                await waitFor(() => {
-                    expect(mapper).toHaveBeenCalled();
-                });
-            });
-        });
-        describe('on an error response', () => {
-            it('throws', async () => {
-                const httpClient = vi.fn().mockResolvedValue(respondWith({}, { status: 400 }));
-                const mapper = vi.fn();
-                const performCollectionQuery = getPerformCollectionQuery(httpClient, { url: '/abcd', method: 'GET' }, mapper);
-                const t = performCollectionQuery({
-                    searchParam: 'query',
-                    signal: new AbortController().signal,
-                });
-                await expect(t).rejects.toThrow(expect.anything());
-            });
-        });
-    });
-});

package/build/domain/features/delay/getStepDelays.js

@@ -1,37 +0,0 @@
-export const getStepDelays = (onEmpty) => {
-    let timeouts = [];
-    const remove = (timeout) => {
-        timeouts = timeouts.filter((pendingTimeout) => pendingTimeout !== timeout);
-    };
-    return {
-        start({ duration, execute }) {
-            const timeout = setTimeout(() => {
-                if (timeouts.includes(timeout)) {
-                    remove(timeout);
-                    execute();
-                }
-                if (timeouts.length === 0) {
-                    onEmpty();
-                }
-            }, duration * 1000);
-            timeouts = [...timeouts, timeout];
-            return {
-                abort: () => {
-                    clearTimeout(timeout);
-                    remove(timeout);
-                    if (timeouts.length === 0) {
-                        onEmpty();
-                    }
-                },
-            };
-        },
-        stop() {
-            if (timeouts.length === 0) {
-                return;
-            }
-            timeouts.forEach(clearTimeout);
-            timeouts = [];
-            onEmpty();
-        },
-    };
-};

package/build/domain/features/delay/getStepDelays.test.js

@@ -1,69 +0,0 @@
-import { getStepDelays } from './getStepDelays';
-describe('getStepDelays', () => {
-    it('executes a delay after the requested number of seconds', () => {
-        const execute = vi.fn();
-        const delays = getStepDelays(vi.fn());
-        delays.start({ duration: 2, execute });
-        vi.advanceTimersByTime(1999);
-        expect(execute).not.toHaveBeenCalled();
-        vi.advanceTimersByTime(1);
-        expect(execute).toHaveBeenCalledOnce();
-    });
-    it('executes multiple delays independently', () => {
-        const executeFirst = vi.fn();
-        const executeSecond = vi.fn();
-        const delays = getStepDelays(vi.fn());
-        delays.start({ duration: 2, execute: executeFirst });
-        delays.start({ duration: 1, execute: executeSecond });
-        vi.advanceTimersByTime(1000);
-        expect(executeSecond).toHaveBeenCalledOnce();
-        expect(executeFirst).not.toHaveBeenCalled();
-        vi.advanceTimersByTime(1000);
-        expect(executeFirst).toHaveBeenCalledOnce();
-    });
-    it('does not execute delays after it is stopped', () => {
-        const execute = vi.fn();
-        const delays = getStepDelays(vi.fn());
-        delays.start({ duration: 1, execute });
-        delays.stop();
-        vi.runAllTimers();
-        expect(execute).not.toHaveBeenCalled();
-    });
-    it('can abort one delay without aborting the others', () => {
-        const executeFirst = vi.fn();
-        const executeSecond = vi.fn();
-        const delays = getStepDelays(vi.fn());
-        const first = delays.start({ duration: 1, execute: executeFirst });
-        delays.start({ duration: 1, execute: executeSecond });
-        first.abort();
-        vi.runAllTimers();
-        expect(executeFirst).not.toHaveBeenCalled();
-        expect(executeSecond).toHaveBeenCalledOnce();
-    });
-    it('executes the provided cleanup function when the delay is complete', () => {
-        const execute = vi.fn();
-        const onDelaysCompleted = vi.fn();
-        const delays = getStepDelays(onDelaysCompleted);
-        delays.start({ duration: 2, execute });
-        vi.advanceTimersByTime(1999);
-        expect(execute).not.toHaveBeenCalled();
-        vi.advanceTimersByTime(1);
-        expect(execute).toHaveBeenCalledOnce();
-        expect(onDelaysCompleted).toHaveBeenCalledOnce();
-    });
-    it('executes the provided cleanup function when the final delay is completed', () => {
-        const execute = vi.fn();
-        const onDelaysCompleted = vi.fn();
-        const delays = getStepDelays(onDelaysCompleted);
-        delays.start({ duration: 2, execute });
-        delays.start({ duration: 4, execute });
-        vi.advanceTimersByTime(1999);
-        expect(execute).not.toHaveBeenCalled();
-        vi.advanceTimersByTime(1);
-        expect(execute).toHaveBeenCalledOnce();
-        expect(onDelaysCompleted).not.toHaveBeenCalled();
-        vi.advanceTimersByTime(2000);
-        expect(execute).toHaveBeenCalledTimes(2);
-        expect(onDelaysCompleted).toHaveBeenCalledOnce();
-    });
-});

package/build/domain/features/domain-event-bus/DomainEventBus.js

@@ -1,24 +0,0 @@
-export class DomainEventBus {
-    constructor() {
-        this.listeners = new Map();
-    }
-    dispatchEvent(eventName, data) {
-        const eventListeners = this.listeners.get(eventName);
-        if (eventListeners) {
-            eventListeners.forEach((callback) => callback(data));
-        }
-    }
-    addEventListener(eventName, callback) {
-        var _a;
-        if (!this.listeners.has(eventName)) {
-            this.listeners.set(eventName, new Set());
-        }
-        (_a = this.listeners.get(eventName)) === null || _a === void 0 ? void 0 : _a.add(callback);
-    }
-    removeEventListener(eventName, callback) {
-        const eventListeners = this.listeners.get(eventName);
-        if (eventListeners) {
-            eventListeners.delete(callback);
-        }
-    }
-}

package/build/domain/features/domain-event-bus/index.js

@@ -1 +0,0 @@
-export { DomainEventBus } from './DomainEventBus';

package/build/domain/features/domain-event-bus/types.js

@@ -1 +0,0 @@
-export {};

package/build/domain/features/eventNames.js

@@ -1,41 +0,0 @@
-export const eventNames = [
-    'Initiated',
-    'Succeeded',
-    'Failed',
-    'Cancelled',
-    'Step Shown',
-    'Action Triggered',
-    'Action Succeeded',
-    'Action Aborted',
-    'Action Failed',
-    'Refresh Triggered',
-    'Refresh Succeeded',
-    'Refresh Aborted',
-    'Refresh Failed',
-    'OneOf Selected',
-    'OneOf Option Selected',
-    'PersistAsync Triggered',
-    'PersistAsync Succeeded',
-    'PersistAsync Failed',
-    'Polling Failed',
-    'ValidationAsync Triggered',
-    'ValidationAsync Succeeded',
-    'ValidationAsync Failed',
-    'Native Subflow Triggered',
-    'Native Subflow Succeeded',
-    'Native Subflow Failed',
-    'Native Subflow Cancelled',
-    'Behavior Triggered',
-    'Collection Search Triggered',
-    'Collection Search Succeeded',
-    'Collection Search Failed',
-    'Collection Filter Triggered',
-    'Collection Filter Succeeded',
-    'Collection Filter Failed',
-    'Collection Pagination Triggered',
-    'Collection Pagination Succeeded',
-    'Collection Pagination Failed',
-    'Updatable Update Triggered', // agree on these names
-    'Updatable Update Succeeded',
-    'Updatable Update Failed',
-];

package/build/domain/features/events.js

@@ -1,5 +0,0 @@
-export const trackBehaviorTriggered = (trackEvent, behavior) => {
-    if (behavior.track) {
-        trackEvent('Behavior Triggered', Object.assign(Object.assign({}, behavior.analytics), { behaviorType: behavior.type }));
-    }
-};

package/build/domain/features/persistAsync/getComponentMultiPersistAsync.js

@@ -1,50 +0,0 @@
-import { isNullish } from '../../../utils/type-validators';
-import { getRandomId } from '../../components/utils/getRandomId';
-/**
- * Creates an onPersistAsync handler for a component.
- */
-export const getComponentMultiPersistAsync = (update, performPersistAsync) => 
-/**
- * Will update the persistedState when a new request is made, and will update
- * the value or set errors when the request completes.
- */
-async (component, index, value) => {
-    if (isNullish(value)) {
-        throw new Error('Value must be a file or base64 string.');
-    }
-    const newAbortController = new AbortController();
-    const { signal } = newAbortController;
-    const newSubmission = performPersistAsync({ value, signal })
-        .then((newValue) => {
-        update(component, (draft) => {
-            draft.persistedState[index].lastResponse = newValue;
-        });
-        return newValue;
-    })
-        .catch((error) => {
-        update(component, (draft) => {
-            // The file was not persisted, so delete it
-            draft.persistedState = [
-                ...draft.persistedState.slice(0, index),
-                ...draft.persistedState.slice(index + 1),
-            ];
-            draft.value.splice(index, 1);
-            draft.files.splice(index, 1);
-        });
-        throw error;
-    });
-    update(component, (draft) => {
-        draft.persistedState = [
-            ...draft.persistedState.slice(0, index),
-            {
-                id: getRandomId(),
-                abortController: newAbortController,
-                lastResponse: null,
-                lastSubmitted: null,
-                submission: newSubmission,
-            },
-            ...draft.persistedState.slice(index),
-        ];
-    });
-    return newSubmission;
-};

package/build/domain/features/persistAsync/getInitialPersistedState.js

@@ -1,7 +0,0 @@
-import { isNullish } from '../../../utils/type-validators';
-export const getInitialPersistedState = (lastSubmitted, model) => ({
-    abortController: new AbortController(),
-    lastSubmitted: !isNullish(model) ? (lastSubmitted !== null && lastSubmitted !== void 0 ? lastSubmitted : null) : null,
-    lastResponse: model !== null && model !== void 0 ? model : null,
-    submission: Promise.resolve(model !== null && model !== void 0 ? model : null),
-});

package/build/domain/features/persistAsync/getPerformPersistAsync.js

@@ -1,43 +0,0 @@
-import { isObject, isString } from '../../../utils/type-validators';
-import { constructPayload } from '../utils/http-utils';
-import { getAnalyticsFromErrorResponse } from '../utils/response-utils';
-/**
- * Takes an httpClient and schema persist async config and returns a function that can
- * execute a persist async request.
- */
-export const getPerformPersistAsync = ({ genericErrorMessage, httpClient, persistAsyncConfig, schemaId, logEvent, trackEvent, }) => {
-    const { idProperty, param, method, url } = persistAsyncConfig;
-    const trackFailure = (json) => {
-        const analytics = getAnalyticsFromErrorResponse(json);
-        trackEvent('PersistAsync Failed', Object.assign({ schema: schemaId }, analytics));
-    };
-    return async function performPersistAsync({ value, signal }) {
-        let response;
-        let json;
-        try {
-            trackEvent('PersistAsync Triggered', { schema: schemaId });
-            response = await httpClient(url, constructPayload({ value, signal, requestConfig: { method, param } }));
-            json = (await response.json());
-            if (response.ok && isObject(json)) {
-                trackEvent('PersistAsync Succeeded', { schema: schemaId });
-                if (json[idProperty] === undefined) {
-                    logEvent('error', `Response from persist async did not contain expected property ${idProperty}.`);
-                    throw new Error(genericErrorMessage);
-                }
-                return json[idProperty];
-            }
-        }
-        catch (_a) {
-            trackFailure();
-            throw new Error(genericErrorMessage);
-        }
-        const validationError = !response.ok && isObject(json) ? getValidationError(param, json) : null;
-        trackFailure(json);
-        throw new Error(validationError !== null && validationError !== void 0 ? validationError : genericErrorMessage);
-    };
-};
-const getValidationError = (param, response) => {
-    var _a;
-    const message = (_a = response.validation) === null || _a === void 0 ? void 0 : _a[param];
-    return isString(message) ? message : null;
-};

package/build/domain/features/persistAsync/getPerformPersistAsync.test.js

@@ -1,139 +0,0 @@
-import { vi } from 'vitest';
-import { getMockHttpClient, respondWith } from '../../../test-utils';
-import { getPerformPersistAsync } from './getPerformPersistAsync';
-describe('getPerformPersistAsync', () => {
-    const genericErrorMessage = 'Error';
-    const trackEvent = vi.fn();
-    const logEvent = vi.fn();
-    const signal = {};
-    const persistAsyncConfig = {
-        idProperty: 'id',
-        method: 'POST',
-        param: 'param',
-        url: '/persist',
-    };
-    it('should make the request using the specified parameter', async () => {
-        const spyHttpClient = vi.fn().mockResolvedValue(respondWith({ id: 1 }));
-        const spyTrackEvent = vi.fn();
-        const performPersistAsync = getPerformPersistAsync({
-            httpClient: spyHttpClient,
-            trackEvent: spyTrackEvent,
-            logEvent,
-            persistAsyncConfig,
-            genericErrorMessage,
-            schemaId: 'schemaId',
-        });
-        await performPersistAsync({ value: 'value', signal });
-        expect(spyHttpClient).toHaveBeenCalledWith('/persist', {
-            body: '{"param":"value"}',
-            headers: { 'Content-Type': 'application/json' },
-            method: 'POST',
-            signal,
-        });
-        expect(spyTrackEvent).toHaveBeenCalledWith('PersistAsync Triggered', expect.objectContaining({ schema: 'schemaId' }));
-    });
-    it('should wrap blobs in form data before submitting', async () => {
-        const spyHttpClient = vi.fn().mockResolvedValue(respondWith({ id: 1 }));
-        const performPersistAsync = getPerformPersistAsync({
-            httpClient: spyHttpClient,
-            trackEvent,
-            logEvent,
-            persistAsyncConfig,
-            genericErrorMessage,
-        });
-        const file = new File(['file'], 'file.txt');
-        await performPersistAsync({ value: file, signal });
-        expect(spyHttpClient).toHaveBeenCalledWith('/persist', {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            body: expect.any(FormData),
-            headers: {},
-            method: 'POST',
-            signal,
-        });
-    });
-    describe('when the response is ok', () => {
-        it('should read response value from idProperty', async () => {
-            const httpClient = getMockHttpClient({
-                '/persist': async () => respondWith({ id: 1 }),
-            });
-            const spyTrackEvent = vi.fn();
-            const performPersistAsync = getPerformPersistAsync({
-                httpClient,
-                trackEvent: spyTrackEvent,
-                logEvent,
-                persistAsyncConfig,
-                genericErrorMessage,
-                schemaId: 'schemaId',
-            });
-            const result = await performPersistAsync({ value: 'value', signal });
-            expect(result).toBe(1);
-            expect(spyTrackEvent).toHaveBeenLastCalledWith('PersistAsync Succeeded', expect.objectContaining({ schema: 'schemaId' }));
-        });
-        it('should throw a generic error if the response is not an object', async () => {
-            const httpClient = getMockHttpClient({
-                '/persist': async () => respondWith(1),
-            });
-            const spyTrackEvent = vi.fn();
-            const performPersistAsync = getPerformPersistAsync({
-                httpClient,
-                trackEvent: spyTrackEvent,
-                logEvent,
-                persistAsyncConfig,
-                genericErrorMessage,
-                schemaId: 'schemaId',
-            });
-            await expect(performPersistAsync({ value: 'value', signal })).rejects.toThrow(genericErrorMessage);
-            expect(spyTrackEvent).toHaveBeenLastCalledWith('PersistAsync Failed', expect.objectContaining({ schema: 'schemaId' }));
-        });
-    });
-    describe.each([[401], [422], [504]])('when the response is %s', (errorStatusCode) => {
-        it('should throw if the response includes a validation message', async () => {
-            const httpClient = getMockHttpClient({
-                '/persist': async () => respondWith({ validation: { param: 'error with this field' } }, { status: errorStatusCode }),
-            });
-            const spyTrackEvent = vi.fn();
-            const performPersistAsync = getPerformPersistAsync({
-                httpClient,
-                trackEvent: spyTrackEvent,
-                logEvent,
-                persistAsyncConfig,
-                genericErrorMessage,
-                schemaId: 'schemaId',
-            });
-            await expect(performPersistAsync({ value: 'value', signal })).rejects.toThrow('error with this field');
-            expect(spyTrackEvent).toHaveBeenLastCalledWith('PersistAsync Failed', expect.objectContaining({ schema: 'schemaId' }));
-        });
-        it('should include analytics if passed', async () => {
-            const httpClient = getMockHttpClient({
-                '/persist': async () => respondWith({ validation: { param: 'error with this field' }, analytics: { some: 'extras' } }, { status: errorStatusCode }),
-            });
-            const spyTrackEvent = vi.fn();
-            const performPersistAsync = getPerformPersistAsync({
-                httpClient,
-                trackEvent: spyTrackEvent,
-                logEvent,
-                persistAsyncConfig,
-                genericErrorMessage,
-                schemaId: 'schemaId',
-            });
-            await expect(performPersistAsync({ value: 'value', signal })).rejects.toThrow('error with this field');
-            expect(spyTrackEvent).toHaveBeenLastCalledWith('PersistAsync Failed', expect.objectContaining({ schema: 'schemaId', some: 'extras' }));
-        });
-    });
-    it('should throw a generic error if request fails', async () => {
-        const httpClient = getMockHttpClient({
-            '/persist': async () => Promise.reject(new Error()),
-        });
-        const spyTrackEvent = vi.fn();
-        const performPersistAsync = getPerformPersistAsync({
-            httpClient,
-            trackEvent: spyTrackEvent,
-            logEvent,
-            persistAsyncConfig,
-            genericErrorMessage,
-            schemaId: 'schemaId',
-        });
-        await expect(performPersistAsync({ value: 'value', signal })).rejects.toThrow(genericErrorMessage);
-        expect(spyTrackEvent).toHaveBeenLastCalledWith('PersistAsync Failed', expect.objectContaining({ schema: 'schemaId' }));
-    });
-});