@wise/dynamic-flow-client 5.28.0 → 5.28.1

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

@@ -1,301 +0,0 @@
-import { mapLayoutToComponent } from '../../mappers/mapLayoutToComponent';
-import { getMockMapperProps } from '../../mappers/schema/tests/test-utils';
-import { getPerformSearchFunction } from './getPerformSearchFunction';
-import { vi } from 'vitest';
-const mockLayoutMapper = vi.fn().mockImplementation((layout) => {
-    return mapLayoutToComponent('uid', layout, getMockMapperProps(), []);
-});
-describe('getSearchFunction returns a function which', () => {
-    describe('when no config is provided', () => {
-        describe('when the default method is GET', () => {
-            const defaultConfig = {
-                url: '/testing',
-                method: 'GET',
-                param: 'query',
-            };
-            it('should use the default config', async () => {
-                const httpClient = vi.fn(async () => Promise.resolve(new Response(JSON.stringify({ results: [] }))));
-                const searchFn = getPerformSearchFunction(httpClient, mockLayoutMapper, defaultConfig);
-                const abortController = new AbortController();
-                await searchFn({
-                    query: 'query',
-                    signal: abortController.signal,
-                });
-                expect(httpClient).toHaveBeenCalledWith(`/testing?${defaultConfig.param}=query`, expect.objectContaining({}));
-            });
-        });
-        describe('when the default method is POST', () => {
-            const defaultConfig = {
-                url: '/testing',
-                method: 'POST',
-                param: 'query',
-            };
-            it('should use the default config', async () => {
-                const httpClient = vi.fn(async () => Promise.resolve(new Response(JSON.stringify({ results: [] }))));
-                const searchFn = getPerformSearchFunction(httpClient, mockLayoutMapper, defaultConfig);
-                const abortController = new AbortController();
-                await searchFn({
-                    query: 'query',
-                    signal: abortController.signal,
-                });
-                expect(httpClient).toHaveBeenCalledWith('/testing', expect.objectContaining({ method: 'POST', body: JSON.stringify({ query: 'query' }) }));
-            });
-        });
-    });
-    describe('when another config is provided', () => {
-        it('ignores the default config', async () => {
-            const defaultConfig = {
-                url: '/old-testing',
-                method: 'GET',
-                param: 'query',
-            };
-            const httpClient = vi.fn(async () => Promise.resolve(new Response(JSON.stringify({ results: [] }))));
-            const searchFn = getPerformSearchFunction(httpClient, mockLayoutMapper, defaultConfig);
-            const abortController = new AbortController();
-            await searchFn({
-                query: 'query',
-                config: { method: 'POST', param: 'term', url: '/new-testing' },
-                signal: abortController.signal,
-            });
-            expect(httpClient).toHaveBeenCalledWith('/new-testing', expect.objectContaining({ method: 'POST', body: JSON.stringify({ term: 'query' }) }));
-        });
-    });
-    describe('when a response is valid (legacy results type)', () => {
-        describe('and the results are empty', () => {
-            it('returns an empty array', async () => {
-                const defaultConfig = {
-                    url: '/testing',
-                    method: 'GET',
-                    param: 'query',
-                };
-                const httpClient = vi.fn(async () => Promise.resolve(new Response(JSON.stringify({ results: [] }))));
-                const searchFn = getPerformSearchFunction(httpClient, mockLayoutMapper, defaultConfig);
-                const abortController = new AbortController();
-                const result = await searchFn({
-                    query: 'query',
-                    signal: abortController.signal,
-                });
-                expect(result).toStrictEqual(expect.objectContaining({
-                    type: 'results',
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                    results: expect.arrayContaining([]),
-                }));
-            });
-        });
-        describe('and the results is not empty', () => {
-            it('returns the results', async () => {
-                const defaultConfig = {
-                    url: '/testing',
-                    method: 'GET',
-                    param: 'query',
-                };
-                const httpClient = vi.fn(async () => Promise.resolve(new Response(JSON.stringify({
-                    results: [
-                        { type: 'action', title: '', value: {} },
-                        {
-                            type: 'search',
-                            title: '',
-                            value: { query: 'query', url: '/testing', method: 'GET', param: 'query' },
-                        },
-                    ],
-                }))));
-                const searchFn = getPerformSearchFunction(httpClient, mockLayoutMapper, defaultConfig);
-                const abortController = new AbortController();
-                const result = await searchFn({
-                    query: 'query',
-                    signal: abortController.signal,
-                });
-                expect(result).toStrictEqual(expect.objectContaining({
-                    type: 'results',
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                    results: expect.arrayContaining([
-                        expect.objectContaining({
-                            type: 'action',
-                            title: '',
-                            value: {},
-                        }),
-                        expect.objectContaining({
-                            type: 'search',
-                            title: '',
-                            value: { query: 'query', url: '/testing', method: 'GET', param: 'query' },
-                        }),
-                    ]),
-                }));
-            });
-        });
-    });
-    describe('when a response is valid (modern results type)', () => {
-        describe('and the results are empty', () => {
-            it('returns an empty array', async () => {
-                const defaultConfig = {
-                    url: '/testing',
-                    method: 'GET',
-                    param: 'query',
-                };
-                const httpClient = vi.fn(async () => Promise.resolve(new Response(JSON.stringify({ type: 'results', results: [] }))));
-                const searchFn = getPerformSearchFunction(httpClient, mockLayoutMapper, defaultConfig);
-                const abortController = new AbortController();
-                const result = await searchFn({
-                    query: 'query',
-                    signal: abortController.signal,
-                });
-                expect(result).toStrictEqual(expect.objectContaining({
-                    type: 'results',
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                    results: expect.arrayContaining([]),
-                }));
-            });
-        });
-        describe('and the results is not empty', () => {
-            it('returns the results', async () => {
-                const defaultConfig = {
-                    url: '/testing',
-                    method: 'GET',
-                    param: 'query',
-                };
-                const httpClient = vi.fn(async () => Promise.resolve(new Response(JSON.stringify({
-                    type: 'results',
-                    results: [
-                        { type: 'action', title: '', value: {} },
-                        {
-                            type: 'search',
-                            title: '',
-                            value: { query: 'query', url: '/testing', method: 'GET', param: 'query' },
-                        },
-                    ],
-                }))));
-                const searchFn = getPerformSearchFunction(httpClient, mockLayoutMapper, defaultConfig);
-                const abortController = new AbortController();
-                const result = await searchFn({
-                    query: 'query',
-                    signal: abortController.signal,
-                });
-                expect(result).toStrictEqual(expect.objectContaining({
-                    type: 'results',
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                    results: expect.arrayContaining([
-                        expect.objectContaining({
-                            type: 'action',
-                            title: '',
-                            value: {},
-                        }),
-                        expect.objectContaining({
-                            type: 'search',
-                            title: '',
-                            value: { query: 'query', url: '/testing', method: 'GET', param: 'query' },
-                        }),
-                    ]),
-                }));
-            });
-        });
-    });
-    describe('when a response is valid (modern layout type)', () => {
-        it('returns the mapped layouts', async () => {
-            const defaultConfig = {
-                url: '/testing',
-                method: 'GET',
-                param: 'query',
-            };
-            const httpClient = vi.fn(async () => Promise.resolve(new Response(JSON.stringify({
-                type: 'layout',
-                content: [
-                    {
-                        type: 'markdown',
-                        content: 'Here is some markdown',
-                    },
-                ],
-            }))));
-            const searchFn = getPerformSearchFunction(httpClient, mockLayoutMapper, defaultConfig);
-            const abortController = new AbortController();
-            const result = await searchFn({
-                query: 'query',
-                signal: abortController.signal,
-            });
-            expect(result).toStrictEqual(expect.objectContaining({
-                type: 'layout',
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                content: expect.arrayContaining([
-                    expect.objectContaining({
-                        type: 'markdown',
-                        uid: 'uid',
-                        content: 'Here is some markdown',
-                    }),
-                ]),
-            }));
-        });
-        describe('and the results is not empty', () => {
-            it('returns the results', async () => {
-                const defaultConfig = {
-                    url: '/testing',
-                    method: 'GET',
-                    param: 'query',
-                };
-                const httpClient = vi.fn(async () => Promise.resolve(new Response(JSON.stringify({
-                    type: 'results',
-                    results: [
-                        { type: 'action', title: '', value: {} },
-                        {
-                            type: 'search',
-                            title: '',
-                            value: { query: 'query', url: '/testing', method: 'GET', param: 'query' },
-                        },
-                    ],
-                }))));
-                const searchFn = getPerformSearchFunction(httpClient, mockLayoutMapper, defaultConfig);
-                const abortController = new AbortController();
-                const result = await searchFn({
-                    query: 'query',
-                    signal: abortController.signal,
-                });
-                expect(result).toStrictEqual(expect.objectContaining({
-                    type: 'results',
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                    results: expect.arrayContaining([
-                        expect.objectContaining({
-                            type: 'action',
-                            title: '',
-                            value: {},
-                        }),
-                        expect.objectContaining({
-                            type: 'search',
-                            title: '',
-                            value: { query: 'query', url: '/testing', method: 'GET', param: 'query' },
-                        }),
-                    ]),
-                }));
-            });
-        });
-    });
-    describe('when a response has an invalid body', () => {
-        it('throws', async () => {
-            const defaultConfig = {
-                url: '/testing',
-                method: 'GET',
-                param: 'query',
-            };
-            const httpClient = vi.fn(async () => Promise.resolve(new Response('invalid body')));
-            const searchFn = getPerformSearchFunction(httpClient, mockLayoutMapper, defaultConfig);
-            const abortController = new AbortController();
-            await expect(searchFn({
-                query: 'query',
-                signal: abortController.signal,
-            })).rejects.toThrow();
-        });
-    });
-    describe('when a response is non-2xx', () => {
-        it('throws', async () => {
-            const defaultConfig = {
-                url: '/testing',
-                method: 'GET',
-                param: 'query',
-            };
-            const httpClient = vi.fn(async () => Promise.resolve(new Response(JSON.stringify({ results: [] }), { status: 400 })));
-            const searchFn = getPerformSearchFunction(httpClient, mockLayoutMapper, defaultConfig);
-            const abortController = new AbortController();
-            await expect(searchFn({
-                query: 'query',
-                signal: abortController.signal,
-            })).rejects.toThrow();
-        });
-    });
-});

package/build/domain/features/summary/summary-utils.js

@@ -1,37 +0,0 @@
-import { isString } from '../../../utils/type-validators';
-import { getDomainLayerMedia } from '../../mappers/utils/media-utils';
-/** A summariser that accepts a schema and returns a function that can form a summary based on a value. */
-export const getSummariser = (schema) => (value) => {
-    const { summary, icon, image, media } = schema;
-    const stringValueOrNull = isString(value) ? value : null;
-    return summaryIfProvides(summary, { value: stringValueOrNull, icon, image, media });
-};
-export const getConstSummary = (schema, model) => {
-    const { summary, icon, image, media } = schema;
-    const value = isString(model) ? model : null;
-    return summaryIfProvides(summary, { value, icon, image, media });
-};
-export const summariseFromChildren = (components) => components.reduce((acc, component) => mergeSummaries(acc, component.getSummary()), {});
-// If there are duplicate props, the first takes precedence
-export const mergeSummaries = (summaryA, summaryB) => { var _a, _b, _c; return ({
-    title: (_a = summaryA.title) !== null && _a !== void 0 ? _a : summaryB.title,
-    description: (_b = summaryA.description) !== null && _b !== void 0 ? _b : summaryB.description,
-    media: (_c = summaryA.media) !== null && _c !== void 0 ? _c : summaryB.media,
-}); };
-const summaryIfProvides = (summary, { value = null, icon, image, media, }) => {
-    var _a;
-    if (!summary) {
-        return {};
-    }
-    const providesMedia = (_a = summary.providesMedia) !== null && _a !== void 0 ? _a : (Boolean(summary.providesIcon) || Boolean(summary.providesImage));
-    const providedMedia = getDomainLayerMedia({
-        icon: summary.providesIcon ? icon : undefined,
-        image: summary.providesImage ? image : undefined,
-        media,
-    });
-    return {
-        title: (summary.providesTitle && value) || undefined,
-        description: (summary.providesDescription && value) || undefined,
-        media: providesMedia ? providedMedia : undefined,
-    };
-};

package/build/domain/features/summary/summary-utils.test.js

@@ -1,125 +0,0 @@
-import { getSummariser, getConstSummary, summariseFromChildren, mergeSummaries, } from './summary-utils';
-import { createMockTextInputComponent } from '../../../test-utils/component-utils';
-describe('summary-utils', () => {
-    describe('getSummariser', () => {
-        it('returns a function that constructs a summary based on the schema and value', () => {
-            const stringSchema = {
-                title: 'title',
-                type: 'string',
-                summary: {
-                    providesTitle: true,
-                    providesIcon: true,
-                },
-                icon: {
-                    name: 'email',
-                },
-            };
-            const summariser = getSummariser(stringSchema);
-            const summary = summariser('test value');
-            expect(summary).toEqual({
-                title: 'test value',
-                media: {
-                    type: 'legacy',
-                    icon: { name: 'email' },
-                },
-            });
-        });
-    });
-    describe('getConstSummary', () => {
-        it('returns a function that constructs a summary based on the schema', () => {
-            const schema = {
-                type: 'string',
-                const: 'const value',
-                summary: {
-                    providesTitle: true,
-                    providesIcon: true,
-                },
-                icon: {
-                    name: 'email',
-                },
-            };
-            const summary = getConstSummary(schema, 'const value');
-            expect(summary).toEqual({
-                title: 'const value',
-                media: {
-                    type: 'legacy',
-                    icon: { name: 'email' },
-                },
-            });
-        });
-        it('prefers ignores non-string values', () => {
-            const schema = {
-                type: 'array',
-                const: [],
-                summary: {
-                    providesTitle: true,
-                    providesIcon: true,
-                },
-                icon: {
-                    name: 'email',
-                },
-            };
-            const summary = getConstSummary(schema, []);
-            expect(summary).toEqual({
-                media: {
-                    type: 'legacy',
-                    icon: { name: 'email' },
-                },
-            });
-        });
-    });
-    describe('summariseFromChildren', () => {
-        it('should merge summaries from an array of components', () => {
-            const components = [
-                createMockTextInputComponent({
-                    summariser: () => ({
-                        title: 'title one',
-                    }),
-                }),
-                createMockTextInputComponent({
-                    summariser: () => ({
-                        title: 'title two',
-                        description: 'description',
-                    }),
-                }),
-            ];
-            expect(summariseFromChildren(components)).toEqual({
-                title: 'title one',
-                description: 'description',
-            });
-        });
-    });
-    describe('mergeSummaries', () => {
-        it('should merge two summaries, prefering earlier props if there are duplicates', () => {
-            const summaryOne = {
-                title: 'title one',
-                description: 'description',
-            };
-            const summaryTwo = {
-                title: 'title two',
-                media: {
-                    type: 'avatar',
-                    content: [
-                        {
-                            type: 'uri',
-                            uri: 'urn:wise:icons:email',
-                        },
-                    ],
-                },
-            };
-            expect(mergeSummaries(summaryOne, summaryTwo)).toEqual({
-                title: 'title one',
-                description: 'description',
-                media: {
-                    type: 'avatar',
-                    content: [
-                        {
-                            type: 'uri',
-                            uri: 'urn:wise:icons:email',
-                        },
-                    ],
-                },
-            });
-        });
-    });
-});

package/build/domain/features/updatable/getPerformUpdateQuery.js

@@ -1,52 +0,0 @@
-import { validateUpdatableResponse, } from '@wise/dynamic-flow-types/spec';
-import { recursiveMerge } from '../../../utils/recursiveMerge';
-export const getPerformUpdateQuery = (httpClient, baseRequest, fallbackLayout, mapState, trackEvent) => {
-    return async (props) => {
-        const { signal } = props;
-        trackEvent('Updatable Update Triggered');
-        try {
-            const response = await performRequest(baseRequest, props, httpClient);
-            if (response.ok) {
-                const results = await parseResponse(response);
-                if (signal.aborted || !results.components) {
-                    return null;
-                }
-                const mappedState = mapState(results);
-                trackEvent('Updatable Update Succeeded');
-                // log analytics event: updatable request success
-                return mappedState;
-            }
-            throw Error('error response', { cause: response });
-        }
-        catch (_a) {
-            if (signal.aborted) {
-                return null;
-            }
-            trackEvent('Updatable Update Failed');
-            return fallbackLayout !== null && fallbackLayout !== void 0 ? fallbackLayout : null; // null means do not update the current state
-        }
-    };
-};
-const performRequest = (request, queryProps, httpClient) => {
-    const { url, method, body, headers } = request;
-    return httpClient(url, {
-        method,
-        headers: Object.assign(Object.assign({}, headers), { 'Content-Type': 'application/json' }),
-        signal: queryProps.signal,
-        body: methodSupportsBody(method)
-            ? JSON.stringify(recursiveMerge(body !== null && body !== void 0 ? body : null, queryProps.data))
-            : undefined,
-    });
-};
-const parseResponse = async (response) => {
-    if (response.ok) {
-        const body = (await response.json());
-        const r = validateUpdatableResponse(body);
-        if (r.valid) {
-            return body;
-        }
-        throw Error(`invalid response body: ${r.errors}`);
-    }
-    throw Error('error response');
-};
-const methodSupportsBody = (method) => ['POST', 'PUT', 'PATCH'].includes(method.toUpperCase());

package/build/domain/features/utils/http-utils.js

@@ -1,21 +0,0 @@
-export function constructPayload({ value, signal, requestConfig, }) {
-    const isFile = value instanceof File;
-    const { method, param } = requestConfig;
-    const body = isFile ? wrapInFormData(param, value) : JSON.stringify({ [param]: value });
-    const headers = Object.assign({}, (!isFile && { 'Content-Type': 'application/json' }));
-    return {
-        method,
-        headers,
-        body,
-        signal,
-    };
-}
-const wrapInFormData = (key, file) => {
-    const formData = new FormData();
-    formData.append(key, file);
-    return formData;
-};
-export const abortAndResetController = (abortController) => {
-    abortController.abort();
-    return new AbortController();
-};

package/build/domain/features/utils/response-utils.js

@@ -1,9 +0,0 @@
-import { isErrorResponseBody } from '../../../controller/response-utils';
-import { isObject } from '../../../utils/type-validators';
-export const getAnalyticsFromErrorResponse = (json) => {
-    if (!isErrorResponseBody(json)) {
-        return undefined;
-    }
-    const { analytics } = json;
-    return isObject(analytics) ? analytics : undefined;
-};

package/build/domain/features/validation/date-availability.js

@@ -1,54 +0,0 @@
-const WEEKDAYS = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
-export const normaliseDateAvailability = (availability, logEvent) => {
-    if (!availability) {
-        return undefined;
-    }
-    const unavailable = availability.unavailable.flatMap((rule) => {
-        if (rule.type === 'weekdays') {
-            return [rule];
-        }
-        if (rule.type === 'dates') {
-            const dates = rule.dates.filter((date) => {
-                const valid = isCanonicalDate(date);
-                if (!valid) {
-                    logInvalidRule(date, logEvent);
-                }
-                return valid;
-            });
-            return dates.length > 0 ? [Object.assign(Object.assign({}, rule), { dates })] : [];
-        }
-        if (!isCanonicalDate(rule.start) || !isCanonicalDate(rule.end) || rule.start > rule.end) {
-            logInvalidRule(`${rule.start}/${rule.end}`, logEvent);
-            return [];
-        }
-        return [rule];
-    });
-    return Object.assign(Object.assign({}, availability), { unavailable });
-};
-export const getUnavailableDateReason = (date, availability) => { var _a; var _b; return (_b = (_a = availability === null || availability === void 0 ? void 0 : availability.unavailable.find((rule) => matchesDateRule(date, rule))) === null || _a === void 0 ? void 0 : _a.reason) !== null && _b !== void 0 ? _b : null; };
-const matchesDateRule = (date, rule) => {
-    switch (rule.type) {
-        case 'dates':
-            return rule.dates.includes(date);
-        case 'weekdays': {
-            const weekday = WEEKDAYS[new Date(`${date}T00:00:00Z`).getUTCDay()];
-            return rule.weekdays.includes(weekday);
-        }
-        case 'range':
-            return date >= rule.start && date <= rule.end;
-    }
-};
-const isCanonicalDate = (value) => {
-    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
-    if (!match) {
-        return false;
-    }
-    const [, year, month, day] = match.map(Number);
-    const date = new Date(0);
-    date.setUTCHours(0, 0, 0, 0);
-    date.setUTCFullYear(year, month - 1, day);
-    return (date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day);
-};
-const logInvalidRule = (value, logEvent) => {
-    logEvent('warning', 'Ignoring invalid date availability rule value', { value });
-};

package/build/domain/features/validation/date-availability.test.js

@@ -1,54 +0,0 @@
-import { getUnavailableDateReason, normaliseDateAvailability } from './date-availability';
-describe('date availability', () => {
-    it('uses the first matching availability reason', () => {
-        const availability = {
-            unavailable: [
-                { type: 'dates', dates: ['2026-12-27'], reason: 'Bank holiday' },
-                { type: 'weekdays', weekdays: ['sun'], reason: 'Closed on Sundays' },
-                { type: 'range', start: '2026-12-20', end: '2026-12-31', reason: 'Winter closure' },
-            ],
-        };
-        expect(getUnavailableDateReason('2026-12-27', availability)).toBe('Bank holiday');
-    });
-    it('removes malformed and impossible dates while retaining valid dates', () => {
-        const logEvent = vi.fn();
-        const availability = {
-            message: 'Some dates are unavailable',
-            unavailable: [
-                {
-                    type: 'dates',
-                    dates: ['2026-09-07', '2026-09-0a', '2026-02-30', '2026-09-08T00:00:00Z'],
-                    reason: 'Unavailable',
-                },
-            ],
-        };
-        expect(normaliseDateAvailability(availability, logEvent)).toEqual({
-            message: 'Some dates are unavailable',
-            unavailable: [{ type: 'dates', dates: ['2026-09-07'], reason: 'Unavailable' }],
-        });
-        expect(logEvent).toHaveBeenCalledTimes(3);
-    });
-    it.each([
-        { start: '2026-09-0a', end: '2026-09-30' },
-        { start: '2026-09-01', end: '2026-02-30' },
-        { start: '2026-09-30', end: '2026-09-01' },
-    ])('removes an invalid range from $start to $end', ({ start, end }) => {
-        const logEvent = vi.fn();
-        const availability = {
-            unavailable: [{ type: 'range', start, end, reason: 'Unavailable' }],
-        };
-        expect(normaliseDateAvailability(availability, logEvent)).toEqual({ unavailable: [] });
-        expect(logEvent).toHaveBeenCalledWith('warning', 'Ignoring invalid date availability rule value', { value: `${start}/${end}` });
-    });
-    it('retains valid ranges and weekday rules', () => {
-        const logEvent = vi.fn();
-        const availability = {
-            unavailable: [
-                { type: 'range', start: '2026-09-01', end: '2026-09-30', reason: 'Closure' },
-                { type: 'weekdays', weekdays: ['sun'], reason: 'Closed on Sundays' },
-            ],
-        };
-        expect(normaliseDateAvailability(availability, logEvent)).toEqual(availability);
-        expect(logEvent).not.toHaveBeenCalled();
-    });
-});