@wise/dynamic-flow-client 5.13.2-experimental-e750b58 → 5.13.2

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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,139 @@
+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' }));
+    });
+});

package/build/domain/features/polling/getStepPolling.js

@@ -0,0 +1,50 @@
+import { getDomainLayerBehavior } from '../../mappers/utils/behavior-utils';
+export const getStepPolling = ({ pollingConfig, logEvent, onBehavior, onPoll, registerSubmissionBehavior, }) => {
+    const { interval, delay = interval, maxAttempts, url, onError } = pollingConfig;
+    let abortController = new AbortController();
+    let intervalRef = null;
+    let hasCompleted = false;
+    if (delay == null) {
+        throw new Error('Polling configuration must include delay or interval');
+    }
+    const onErrorBehavior = getDomainLayerBehavior(onError, [], registerSubmissionBehavior);
+    let attempts = 0;
+    const poll = () => {
+        attempts += 1;
+        abortController.abort();
+        abortController = new AbortController();
+        const { signal } = abortController;
+        onPoll(url, onErrorBehavior, signal)
+            .then((result) => {
+            if (result) {
+                complete();
+                return;
+            }
+            if (attempts >= maxAttempts && !signal.aborted) {
+                complete();
+                void onBehavior(onErrorBehavior);
+            }
+        })
+            .catch(() => { });
+    };
+    const complete = () => {
+        hasCompleted = true;
+        stop();
+    };
+    const start = () => {
+        if (hasCompleted) {
+            return;
+        }
+        intervalRef = setInterval(poll, delay * 1000);
+        poll();
+    };
+    const stop = () => {
+        if (!intervalRef) {
+            logEvent('warning', 'Attempted to stop polling but it was not started');
+            return;
+        }
+        clearInterval(intervalRef);
+        abortController.abort();
+    };
+    return { start, stop };
+};

package/build/domain/features/polling/getStepPolling.test.js

@@ -0,0 +1,115 @@
+import { getStepPolling } from './getStepPolling';
+import { vi } from 'vitest';
+describe('getStepPolling', () => {
+    it('when called will start polling', async () => {
+        const onPoll = vi.fn().mockImplementation(async () => Promise.resolve());
+        getStepPolling({
+            pollingConfig: {
+                url: '/polling',
+                maxAttempts: 5,
+                interval: 1,
+                onError: { action: { url: '/failure' } },
+            },
+            logEvent: vi.fn(),
+            onBehavior: vi.fn(),
+            onPoll,
+            registerSubmissionBehavior: vi.fn(),
+        }).start();
+        expect(onPoll).toHaveBeenCalledTimes(1);
+        await vi.advanceTimersByTimeAsync(1000);
+        expect(onPoll).toHaveBeenCalledTimes(2);
+        await vi.advanceTimersByTimeAsync(1000);
+        expect(onPoll).toHaveBeenCalledTimes(3);
+    });
+    it('the interval between polls is defined by the pollingConfig', async () => {
+        const onPoll = vi.fn().mockImplementation(async () => Promise.resolve());
+        const interval = 4;
+        getStepPolling({
+            pollingConfig: {
+                url: '/polling',
+                maxAttempts: 5,
+                interval,
+                onError: { action: { url: '/failure' } },
+            },
+            logEvent: vi.fn(),
+            onBehavior: vi.fn(),
+            onPoll,
+            registerSubmissionBehavior: vi.fn(),
+        }).start();
+        expect(onPoll).toHaveBeenCalledTimes(1);
+        await vi.advanceTimersByTimeAsync(interval * 1000);
+        expect(onPoll).toHaveBeenCalledTimes(2);
+        await vi.advanceTimersByTimeAsync(interval * 1000);
+        expect(onPoll).toHaveBeenCalledTimes(3);
+    });
+    it('will only poll a number of times defined by maxAttempts - and will trigger the onError action if it reaches this without a valid response', async () => {
+        const onPoll = vi.fn().mockImplementation(async () => Promise.resolve(false));
+        const onBehavior = vi.fn();
+        getStepPolling({
+            pollingConfig: {
+                url: '/polling',
+                maxAttempts: 5,
+                interval: 1,
+                onError: { action: { url: '/failure' } },
+            },
+            logEvent: vi.fn(),
+            onBehavior,
+            onPoll,
+            registerSubmissionBehavior: vi.fn(),
+        }).start();
+        await vi.advanceTimersByTimeAsync(5000);
+        expect(onPoll).toHaveBeenCalledTimes(5);
+        expect(onBehavior).toHaveBeenCalledTimes(1);
+        expect(onBehavior).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'action',
+            action: expect.objectContaining({ url: '/failure' }),
+        }));
+    });
+    it('will stop polling once a flow response is received, and it will not restart polling if start is called again', async () => {
+        const onPoll = vi.fn().mockImplementation(async () => {
+            // Simulate receiving a flow response, which should stop polling and resolve to true
+            return Promise.resolve(true);
+        });
+        const polling = getStepPolling({
+            pollingConfig: {
+                url: '/polling',
+                maxAttempts: 5,
+                interval: 1,
+                onError: { action: { url: '/failure' } },
+            },
+            logEvent: vi.fn(),
+            onBehavior: vi.fn(),
+            onPoll,
+            registerSubmissionBehavior: vi.fn(),
+        });
+        polling.start();
+        expect(onPoll).toHaveBeenCalledTimes(1);
+        await vi.advanceTimersByTimeAsync(1000);
+        expect(onPoll).toHaveBeenCalledTimes(1);
+        polling.start();
+        await vi.advanceTimersByTimeAsync(1000);
+        expect(onPoll).toHaveBeenCalledTimes(1);
+    });
+    it('returns an object with a function that stops polling', async () => {
+        const onPoll = vi.fn().mockImplementation(async () => Promise.resolve());
+        const { start, stop } = getStepPolling({
+            pollingConfig: {
+                url: '/polling',
+                maxAttempts: 5,
+                interval: 1,
+                onError: { action: { url: '/failure' } },
+            },
+            logEvent: vi.fn(),
+            onBehavior: vi.fn(),
+            onPoll,
+            registerSubmissionBehavior: vi.fn(),
+        });
+        start();
+        expect(onPoll).toHaveBeenCalledTimes(1);
+        await vi.advanceTimersByTimeAsync(2000);
+        expect(onPoll).toHaveBeenCalledTimes(3);
+        stop();
+        await vi.advanceTimersByTimeAsync(2000);
+        expect(onPoll).toHaveBeenCalledTimes(3);
+    });
+});

package/build/domain/features/prefetch/getStepPrefetch.js

@@ -0,0 +1,43 @@
+import { createRequestFromAction } from '../../../controller/executeSubmission';
+import { makeRequestCacheKey, makeRequestCacheWithParent } from './request-cache';
+export const getStepPrefetch = (httpClient, flowRequestCache, submissionBehaviors) => {
+    const requestCache = makeRequestCacheWithParent(flowRequestCache);
+    // keep track of all prefetched actions in this step so duplicate requests
+    // aren't made
+    const keys = new Set();
+    const start = (model) => {
+        if (keys.size > 0) {
+            return;
+        }
+        submissionBehaviors.forEach((behavior) => {
+            const request = behavior.type === 'action'
+                ? createRequestFromAction(behavior.action, model)
+                : behavior.launchConfig.request;
+            const requestParams = [
+                request.url,
+                {
+                    body: JSON.stringify(request.body),
+                    method: request.method,
+                    headers: { 'Content-Type': 'application/json' },
+                },
+            ];
+            try {
+                const key = makeRequestCacheKey(requestParams);
+                if (keys.has(key)) {
+                    return;
+                }
+                const responsePromise = httpClient(...requestParams).catch(() => null);
+                requestCache.set(requestParams, responsePromise);
+                // eslint-disable-next-line functional/immutable-data
+                keys.add(key);
+            }
+            catch (_a) {
+                // if fetch fails synchronously, we do not cache the request
+            }
+        });
+    };
+    const stop = () => {
+        // no-op for now
+    };
+    return { requestCache, start, stop };
+};

package/build/domain/features/prefetch/request-cache.js

@@ -0,0 +1,49 @@
+/* we can disable this rule here because a cache is inherently mutable */
+/* eslint-disable functional/immutable-data */
+export const makeRequestCacheWithParent = (parent) => {
+    const map = new Map();
+    const cache = {
+        get: (requestParams) => {
+            var _a;
+            const key = makeRequestCacheKey(requestParams);
+            const promise = (_a = map.get(key)) !== null && _a !== void 0 ? _a : parent === null || parent === void 0 ? void 0 : parent.get(requestParams);
+            map.delete(key);
+            return promise;
+        },
+        set: (requestParams, responsePromise) => {
+            return map.set(makeRequestCacheKey(requestParams), responsePromise);
+        },
+    };
+    return cache;
+};
+export const makeRequestCache = (initialValues = []) => {
+    const cache = makeRequestCacheWithParent(undefined);
+    initialValues.forEach(([requestParams, responsePromise]) => {
+        cache.set(requestParams, responsePromise);
+    });
+    return cache;
+};
+export const normaliseRequestCache = (cache) => {
+    if (cache === undefined) {
+        return makeRequestCache();
+    }
+    if (isRequestCacheInstance(cache)) {
+        return cache;
+    }
+    return makeRequestCache(cache);
+};
+const isRequestCacheInstance = (cache) => {
+    return !cache || !Array.isArray(cache);
+};
+export const makeRequestCacheKey = (requestParams) => {
+    var _a, _b;
+    const [input, init] = requestParams;
+    const url = typeof input === 'string' || input instanceof URL ? input.toString() : input.url;
+    const key = JSON.stringify({
+        url,
+        method: (_a = init === null || init === void 0 ? void 0 : init.method) !== null && _a !== void 0 ? _a : 'GET',
+        headers: (init === null || init === void 0 ? void 0 : init.headers) ? Array.from(new Headers(init.headers).entries()) : [],
+        body: (_b = init === null || init === void 0 ? void 0 : init.body) !== null && _b !== void 0 ? _b : null,
+    });
+    return key;
+};

package/build/domain/features/prefetch/request-cache.test.js

@@ -0,0 +1,70 @@
+import { makeRequestCache, makeRequestCacheWithParent } from './request-cache';
+describe('RequestCache', () => {
+    it('should.set and.get requests correctly, discriminating by URL and method', async () => {
+        var _a, _b, _c, _d;
+        const cache = makeRequestCache();
+        cache.set(['/request-a', { method: 'GET' }], Promise.resolve(new Response('cached response: a GET')));
+        cache.set(['/request-a', { method: 'POST' }], Promise.resolve(new Response('cached response: a POST')));
+        cache.set(['/request-b', { method: 'GET' }], Promise.resolve(new Response('cached response: b GET')));
+        cache.set(['/request-b', { method: 'POST' }], Promise.resolve(new Response('cached response: b POST')));
+        const promiseAget = cache.get(['/request-a', { method: 'GET' }]);
+        expect(promiseAget).toBeDefined();
+        expect(promiseAget && (await ((_a = (await promiseAget)) === null || _a === void 0 ? void 0 : _a.text()))).toBe('cached response: a GET');
+        const nonCachedPromise = cache.get(['/request-c', { method: 'GET' }]);
+        expect(nonCachedPromise).toBeUndefined();
+        const promiseApost = cache.get(['/request-a', { method: 'POST' }]);
+        expect(promiseApost).toBeDefined();
+        expect(promiseApost && (await ((_b = (await promiseApost)) === null || _b === void 0 ? void 0 : _b.text()))).toBe('cached response: a POST');
+        const promiseBget = cache.get(['/request-b', { method: 'GET' }]);
+        expect(promiseBget).toBeDefined();
+        expect(promiseBget && (await ((_c = (await promiseBget)) === null || _c === void 0 ? void 0 : _c.text()))).toBe('cached response: b GET');
+        const promiseBpost = cache.get(['/request-b', { method: 'POST' }]);
+        expect(promiseBpost).toBeDefined();
+        expect(promiseBpost && (await ((_d = (await promiseBpost)) === null || _d === void 0 ? void 0 : _d.text()))).toBe('cached response: b POST');
+    });
+    it('should also discriminate when headers are different', async () => {
+        var _a, _b;
+        const cache = makeRequestCache();
+        cache.set(['/request-a', { headers: { 'X-Custom-Header': 'Value1' } }], Promise.resolve(new Response('cached response: header Value1')));
+        cache.set(['/request-a', { headers: { 'X-Custom-Header': 'Value2' } }], Promise.resolve(new Response('cached response: header Value2')));
+        const promiseHeader1 = cache.get(['/request-a', { headers: { 'X-Custom-Header': 'Value1' } }]);
+        expect(promiseHeader1).toBeDefined();
+        expect(promiseHeader1 && (await ((_a = (await promiseHeader1)) === null || _a === void 0 ? void 0 : _a.text()))).toBe('cached response: header Value1');
+        const promiseHeader2 = cache.get(['/request-a', { headers: { 'X-Custom-Header': 'Value2' } }]);
+        expect(promiseHeader2).toBeDefined();
+        expect(promiseHeader2 && (await ((_b = (await promiseHeader2)) === null || _b === void 0 ? void 0 : _b.text()))).toBe('cached response: header Value2');
+    });
+    it('should also discriminate when bodies are different', async () => {
+        var _a, _b;
+        const cache = makeRequestCache();
+        cache.set(['/request-a', { method: 'POST', body: 'body1' }], Promise.resolve(new Response('cached response: body1')));
+        cache.set(['/request-a', { method: 'POST', body: 'body2' }], Promise.resolve(new Response('cached response: body2')));
+        const promiseBody1 = cache.get(['/request-a', { method: 'POST', body: 'body1' }]);
+        expect(promiseBody1).toBeDefined();
+        expect(promiseBody1 && (await ((_a = (await promiseBody1)) === null || _a === void 0 ? void 0 : _a.text()))).toBe('cached response: body1');
+        const promiseBody2 = cache.get(['/request-a', { method: 'POST', body: 'body2' }]);
+        expect(promiseBody2).toBeDefined();
+        expect(promiseBody2 && (await ((_b = (await promiseBody2)) === null || _b === void 0 ? void 0 : _b.text()))).toBe('cached response: body2');
+    });
+    describe('when given a parent cache', () => {
+        it('gets from the child cache first if present', async () => {
+            var _a;
+            const parent = makeRequestCache();
+            parent.set(['/abc', { method: 'POST', body: 'abc' }], Promise.resolve(new Response('cached response: abc')));
+            const child = makeRequestCacheWithParent(parent);
+            child.set(['/abc', { method: 'POST', body: 'abc' }], Promise.resolve(new Response('cached response: def')));
+            const promiseBody = child.get(['/abc', { method: 'POST', body: 'abc' }]);
+            expect(promiseBody).toBeDefined();
+            expect(promiseBody && (await ((_a = (await promiseBody)) === null || _a === void 0 ? void 0 : _a.text()))).toBe('cached response: def');
+        });
+        it('gets from the parent cache if not present in the child', async () => {
+            var _a;
+            const parent = makeRequestCache();
+            parent.set(['/abc', { method: 'POST', body: 'abc' }], Promise.resolve(new Response('cached response: abc')));
+            const child = makeRequestCacheWithParent(parent);
+            const promiseBody1 = child.get(['/abc', { method: 'POST', body: 'abc' }]);
+            expect(promiseBody1).toBeDefined();
+            expect(promiseBody1 && (await ((_a = (await promiseBody1)) === null || _a === void 0 ? void 0 : _a.text()))).toBe('cached response: abc');
+        });
+    });
+});

package/build/domain/features/refreshAfter/getStepRefreshAfter.js

@@ -0,0 +1,24 @@
+const ONE_SECOND = 1000;
+export const getStepRefreshAfter = ({ refreshAfter, logEvent, onBehavior, }) => {
+    let timeout = null;
+    const targetTime = new Date(refreshAfter).getTime();
+    if (typeof refreshAfter !== 'string' || Number.isNaN(targetTime)) {
+        throw new Error(`Invalid refreshAfter value: ${String(refreshAfter)}`);
+    }
+    const start = () => {
+        const timeLeft = Math.max(targetTime - Date.now(), ONE_SECOND);
+        timeout = setTimeout(() => {
+            void onBehavior({ type: 'refresh', analytics: { schema: 'refreshAfter' } });
+        }, timeLeft);
+    };
+    return {
+        start,
+        stop: () => {
+            if (!timeout) {
+                logEvent('warning', 'Attempted to stop refreshAfter but it was not started');
+                return;
+            }
+            clearTimeout(timeout);
+        },
+    };
+};

package/build/domain/features/refreshAfter/getStepRefreshAfter.test.js

@@ -0,0 +1,40 @@
+import { vi } from 'vitest';
+import { getStepRefreshAfter } from './getStepRefreshAfter';
+describe('getStepRefreshAfter', () => {
+    describe('valid ISO 8601 strings (and supported by JS Date)', () => {
+        const validIso8601Strings = [
+            ['date, hours, minutes, seconds, no timezone', '2025-03-12T12:00:00'],
+            ['date, hours, minutes, seconds, timezone Z', '2025-03-12T12:00:00Z'],
+            ['date, hours, minutes, seconds, timezone +01:00', '2025-03-12T12:00:00+01:00'],
+            ['date, hours, minutes, seconds, timezone -01:00', '2025-03-12T12:00:00-01:00'],
+            ['date, hours, minutes, seconds.milliseconds, timezone Z', '2025-03-12T12:00:00.000Z'],
+            [
+                'date, hours, minutes, seconds.milliseconds, timezone +HH:mm',
+                '2025-03-12T12:00:00.000+01:00',
+            ],
+            [
+                'date, hours, minutes, seconds.milliseconds, timezone +HHmm',
+                '2025-03-12T12:00:00.000+0100',
+            ],
+        ];
+        describe.each(validIso8601Strings)('%s', (_, refreshAfter) => {
+            it(`it returns a StepRefreshAfter object for "${refreshAfter}"`, () => {
+                expect(getStepRefreshAfter({ refreshAfter, logEvent: vi.fn(), onBehavior: vi.fn() })).toBeDefined();
+            });
+        });
+    });
+    describe('invalid ISO 8601 strings (or not supported by JS Date)', () => {
+        const invalidIso8601Strings = [
+            ['random word', 'banana'],
+            ['random word', 'now'],
+            ['unix timestamp', '1741780800'],
+            ['basic date string: missing dashes and colons', '20250312T120000'],
+            ['two-digit timezone +HH', '2025-03-12T12:00:00.000+01'],
+        ];
+        describe.each(invalidIso8601Strings)('%s', (_, refreshAfter) => {
+            it(`it should throw for "${refreshAfter}"`, () => {
+                expect(() => getStepRefreshAfter({ refreshAfter, logEvent: vi.fn(), onBehavior: vi.fn() })).toThrow(`Invalid refreshAfter value: ${refreshAfter}`);
+            });
+        });
+    });
+});