@wise/dynamic-flow-client 5.9.1 → 5.9.2-logging-bf0bd22

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,40 +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/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/spec-utils.js

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

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

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

@@ -1,108 +0,0 @@
-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([]);
-    });
-});