@wise/dynamic-flow-client 5.9.2-logging-2-70d602d → 5.9.2

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

@@ -0,0 +1,43 @@
+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;
+    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) {
+                stop();
+                return;
+            }
+            if (attempts >= maxAttempts && !signal.aborted) {
+                void onBehavior(onErrorBehavior);
+                stop();
+            }
+        })
+            .catch(() => { });
+    };
+    const start = () => {
+        attempts = 0;
+        intervalRef = setInterval(poll, delay * 1000);
+        poll();
+    };
+    const stop = () => {
+        if (!intervalRef) {
+            logEvent('warning', 'Attempted to stop polling but it was not started');
+            return;
+        }
+        clearTimeout(intervalRef);
+        abortController.abort();
+    };
+    return { start, stop };
+};

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

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

package/build/domain/features/schema-on-change/getDebouncedSchemaOnChange.js

@@ -0,0 +1,50 @@
+/* eslint-disable functional/immutable-data */
+import { debounce } from '../../components/utils/debounce';
+import { isOrWasValid } from '../../components/utils/isOrWasValid';
+const debounceDelay = 1000;
+export const getDebouncedSchemaOnChange = (onChange, getValidationErrors) => {
+    if (!onChange) {
+        return undefined;
+    }
+    const performOnChange = onChange.behaviorType === 'refresh'
+        ? getSelectiveDebouncedSchemaOnChange(onChange, getValidationErrors)
+        : debounce(onChange, debounceDelay);
+    return performOnChange;
+};
+const getSelectiveDebouncedSchemaOnChange = (onChange, getValidationErrors) => {
+    let behaviorControl = { abort: () => { } };
+    let timeoutId = null;
+    const clearTimer = () => {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+        timeoutId = null;
+    };
+    const flush = () => {
+        if (timeoutId !== null) {
+            void onChange().then((bc) => {
+                behaviorControl = bc;
+            });
+            clearTimer();
+        }
+    };
+    const debouncedOnChange = (prevValue, updatedValue) => {
+        var _a;
+        const valid = isOrWasValid(getValidationErrors, prevValue, updatedValue);
+        const isPending = timeoutId !== null;
+        if (valid || isPending) {
+            (_a = behaviorControl.abort) === null || _a === void 0 ? void 0 : _a.call(behaviorControl);
+            clearTimer();
+            timeoutId = setTimeout(() => flush(), debounceDelay);
+        }
+    };
+    debouncedOnChange.cancel = () => {
+        var _a;
+        clearTimer();
+        (_a = behaviorControl.abort) === null || _a === void 0 ? void 0 : _a.call(behaviorControl);
+    };
+    debouncedOnChange.flush = () => {
+        flush();
+    };
+    return debouncedOnChange;
+};

package/build/domain/features/schema-on-change/getSchemaOnChange.js

@@ -0,0 +1,34 @@
+import { normaliseBehavior } from '../../mappers/utils/behavior-utils';
+export const getSchemaOnChange = (schema, onBehavior) => {
+    var _a, _b;
+    const behavior = (_b = (_a = getBehaviorFromSchemaOnChange(schema)) !== null && _a !== void 0 ? _a : getBehaviorFromSchemaRefreshStepOnChange(schema)) !== null && _b !== void 0 ? _b : undefined;
+    if (behavior) {
+        const onChange = async () => onBehavior(behavior);
+        // eslint-disable-next-line functional/immutable-data
+        onChange.behaviorType = behavior.type;
+        return onChange;
+    }
+    return undefined;
+};
+const getBehaviorFromSchemaOnChange = (schema) => {
+    if ('onChange' in schema && schema.onChange) {
+        const { $id, analyticsId, onChange } = schema;
+        const behavior = Object.assign(Object.assign({}, normaliseBehavior(onChange, [])), { analytics: { schema: analyticsId !== null && analyticsId !== void 0 ? analyticsId : $id } });
+        return behavior;
+    }
+    return undefined;
+};
+const getBehaviorFromSchemaRefreshStepOnChange = (schema) => {
+    var _a, _b;
+    if (('refreshStepOnChange' in schema && ((_a = schema.refreshStepOnChange) !== null && _a !== void 0 ? _a : false)) ||
+        ('refreshFormOnChange' in schema && ((_b = schema.refreshFormOnChange) !== null && _b !== void 0 ? _b : false))) {
+        const { $id, analyticsId, refreshUrl, refreshFormUrl } = schema;
+        const behavior = {
+            type: 'refresh',
+            analytics: { schema: analyticsId !== null && analyticsId !== void 0 ? analyticsId : $id },
+            url: refreshUrl !== null && refreshUrl !== void 0 ? refreshUrl : refreshFormUrl,
+        };
+        return behavior;
+    }
+    return undefined;
+};

package/build/domain/features/search/getPerformSearchFunction.js

@@ -0,0 +1,75 @@
+import { isArray, isObject } from '../../../utils/type-validators';
+export const getPerformSearchFunction = (httpClient, mapLayoutToDomainComponent, defaultConfig) => {
+    let latestSuccessfulRequestHash = hashRequest('', defaultConfig);
+    let latestSuccessfulResults = null;
+    return async ({ config = defaultConfig, query, signal }) => {
+        const requestHash = hashRequest(query, config);
+        if (requestHash !== latestSuccessfulRequestHash) {
+            const { method, param, url } = config;
+            const headers = { 'Content-Type': 'application/json' };
+            const response = await (method === 'GET'
+                ? httpClient(addQueryParameter(url, param, query), {
+                    method,
+                    headers,
+                    signal,
+                })
+                : httpClient(url, {
+                    method,
+                    headers,
+                    signal,
+                    body: JSON.stringify({ [param]: query }),
+                }));
+            const results = await parseResponse(response);
+            // eslint-disable-next-line require-atomic-updates
+            latestSuccessfulRequestHash = requestHash;
+            if (results.type === 'layout') {
+                const mappedLayoutResult = {
+                    type: 'layout',
+                    content: results.content.map(mapLayoutToDomainComponent),
+                };
+                latestSuccessfulResults = mappedLayoutResult;
+                return mappedLayoutResult;
+            }
+            latestSuccessfulResults = results;
+            return results;
+        }
+        return latestSuccessfulResults;
+    };
+};
+const parseResponse = async (response) => {
+    if (response.ok) {
+        const body = await response.json().catch(() => null);
+        if (isValidResponseBody(body)) {
+            if (body.type === 'layout') {
+                return body;
+            }
+            if (body.results) {
+                return {
+                    type: 'results',
+                    results: body.results,
+                };
+            }
+        }
+    }
+    throw Error('error response');
+};
+const addQueryParameter = (url, key, value) => {
+    const [urlBase, urlQuery] = url.split('?');
+    const urlQueryParams = new URLSearchParams(urlQuery);
+    urlQueryParams.set(key, value);
+    return `${urlBase}?${urlQueryParams.toString()}`;
+};
+const isValidResponseBody = (body) => {
+    if (!isObject(body)) {
+        return false;
+    }
+    if ('results' in body) {
+        return (isArray(body.results) &&
+            body.results.every((result) => isObject(result) && 'title' in result && 'type' in result && 'value' in result));
+    }
+    if ('type' in body && body.type === 'layout' && 'content' in body) {
+        return isArray(body.content);
+    }
+    return false;
+};
+const hashRequest = (query, config) => JSON.stringify({ query, config });