@wise/dynamic-flow-client 5.8.1 → 5.9.0

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

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

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

@@ -0,0 +1,125 @@
+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/utils/http-utils.js

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

@@ -0,0 +1,9 @@
+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/spec-utils.js

@@ -0,0 +1,19 @@
+import { vi } from 'vitest';
+export const mockErrorMessageFunctions = {
+    minimum: vi.fn().mockReturnValue('minimum'),
+    maximum: vi.fn().mockReturnValue('maximum'),
+    minimumDate: vi.fn().mockReturnValue('minimumDate'),
+    maximumDate: vi.fn().mockReturnValue('maximumDate'),
+    minLength: vi.fn().mockReturnValue('minLength'),
+    maxLength: vi.fn().mockReturnValue('maxLength'),
+    minFiles: vi.fn().mockReturnValue('minFiles'),
+    maxFiles: vi.fn().mockReturnValue('maxFiles'),
+    minItems: vi.fn().mockReturnValue('minItems'),
+    maxItems: vi.fn().mockReturnValue('maxItems'),
+    maxSize: vi.fn().mockReturnValue('maxSize'),
+    accepts: vi.fn().mockReturnValue('accepts'),
+    pattern: vi.fn().mockReturnValue('pattern'),
+    required: vi.fn().mockReturnValue('required'),
+    genericError: vi.fn().mockReturnValue('genericError'),
+    genericErrorWithRetry: vi.fn().mockReturnValue('genericErrorWithRetry'),
+};

package/build/domain/features/validation/validateStringPattern.js

@@ -0,0 +1,24 @@
+export const validateStringPattern = (pattern, logEvent) => {
+    if (!pattern) {
+        return;
+    }
+    try {
+        new RegExp(pattern, 'u');
+    }
+    catch (error) {
+        const message = `Invalid schema pattern. Failed to instantiate RegExp with Unicode support.`;
+        if (logEvent) {
+            logEvent('warning', message, {
+                pattern,
+                error: error === null || error === void 0 ? void 0 : error.toString(),
+            });
+        }
+        else {
+            // eslint-disable-next-line no-console
+            console.warn(`DynamicFlow - warning - ${message}`, {
+                pattern,
+                error: error === null || error === void 0 ? void 0 : error.toString(),
+            });
+        }
+    }
+};

package/build/domain/features/validation/validation-functions.js

@@ -0,0 +1,6 @@
+import { isString } from '../../../utils/type-validators';
+export const validateComponents = (components) => components.reduce((acc, component) => component.validate() && acc, true);
+/**
+ * Returns a function that takes a local value and returns an array of validation errors
+ */
+export const getLocalValueValidator = (checks) => (currentValue) => checks.map((check) => check(currentValue)).filter(isString);

package/build/domain/features/validation/validation-functions.test.js

@@ -0,0 +1,108 @@
+import { vi } from 'vitest';
+import { mockErrorMessageFunctions } from './spec-utils';
+import { getLocalValueValidator, validateComponents } from './validation-functions';
+import { getAboveMaxLengthCheck, getAboveMaximumCheck, getBelowMinLengthCheck, getBelowMinimumCheck, getNotAdheringToPatternCheck, getRequiredCheck, } from './value-checks';
+const getMockComponent = ({ valid }) => ({ validate: vi.fn().mockReturnValue(valid) });
+describe('validateComponents', () => {
+    it('should return true when all components validate', () => {
+        const components = [
+            getMockComponent({ valid: true }),
+            getMockComponent({ valid: true }),
+            getMockComponent({ valid: true }),
+        ];
+        const result = validateComponents(components);
+        expect(result).toBe(true);
+    });
+    it('should return false when at least one component fails to validate', () => {
+        const components = [
+            getMockComponent({ valid: true }),
+            getMockComponent({ valid: false }),
+            getMockComponent({ valid: true }),
+        ];
+        const result = validateComponents(components);
+        expect(result).toBe(false);
+    });
+    it('should return true when there are no components', () => {
+        const components = [];
+        const result = validateComponents(components);
+        expect(result).toBe(true);
+    });
+    it('should call validate on every component', () => {
+        const validateOne = vi.fn().mockReturnValue(false);
+        const validateTwo = vi.fn().mockReturnValue(true);
+        const validateThree = vi.fn().mockReturnValue(true);
+        const components = [
+            { validate: validateOne },
+            { validate: validateTwo },
+            { validate: validateThree },
+        ];
+        validateComponents(components);
+        expect(validateOne).toHaveBeenCalled();
+        expect(validateTwo).toHaveBeenCalled();
+        expect(validateThree).toHaveBeenCalled();
+    });
+});
+describe('getLocalValueValidator', () => {
+    it('returns an empty array when the model is valid', () => {
+        const schema = {
+            type: 'integer',
+            minimum: 1,
+            maximum: 90,
+        };
+        const checks = [
+            getRequiredCheck(false, mockErrorMessageFunctions),
+            getBelowMinimumCheck(schema, mockErrorMessageFunctions),
+            getAboveMaximumCheck(schema, mockErrorMessageFunctions),
+        ];
+        const validationErrors = getLocalValueValidator(checks)(30);
+        expect(validationErrors).toEqual([]);
+    });
+    it('returns an array of validation errors when the model is invalid', () => {
+        const schema = {
+            type: 'string',
+            minLength: 3,
+            maxLength: 10,
+            pattern: 'foo',
+        };
+        const checks = [
+            getRequiredCheck(false, mockErrorMessageFunctions),
+            getAboveMaxLengthCheck(schema, mockErrorMessageFunctions),
+            getBelowMinLengthCheck(schema, mockErrorMessageFunctions),
+            getNotAdheringToPatternCheck(schema, mockErrorMessageFunctions),
+        ];
+        const validationErrors = getLocalValueValidator(checks)('invalid-model');
+        expect(validationErrors).toEqual(['maxLength', 'pattern']);
+    });
+    it('returns a single error if the model is required and not provided', () => {
+        const schema = {
+            type: 'string',
+            minLength: 3,
+            maxLength: 10,
+            pattern: 'foo',
+        };
+        const checks = [
+            getRequiredCheck(true, mockErrorMessageFunctions),
+            getAboveMaxLengthCheck(schema, mockErrorMessageFunctions),
+            getBelowMinLengthCheck(schema, mockErrorMessageFunctions),
+            getNotAdheringToPatternCheck(schema, mockErrorMessageFunctions),
+        ];
+        const validationErrors = getLocalValueValidator(checks)(null);
+        expect(validationErrors).toEqual(['required']);
+    });
+    it('returns an empty array when the model is not required and not provided', () => {
+        const schema = {
+            type: 'string',
+            minLength: 3,
+            maxLength: 10,
+            pattern: 'foo',
+        };
+        const checks = [
+            getRequiredCheck(false, mockErrorMessageFunctions),
+            getAboveMaxLengthCheck(schema, mockErrorMessageFunctions),
+            getBelowMinLengthCheck(schema, mockErrorMessageFunctions),
+            getNotAdheringToPatternCheck(schema, mockErrorMessageFunctions),
+        ];
+        const validationErrors = getLocalValueValidator(checks)(null);
+        expect(validationErrors).toEqual([]);
+    });
+});