baldrick-broth/dist/format-message.js

Build automation tool and task runner

const read = (obj, key) => obj && typeof obj === 'object'
    ? obj[key]
    : undefined;
export const formatMessage = (issue) => {
    const path = issue.path.join('.');
    switch (issue.code) {
        case 'invalid_type': {
            return {
                path,
                message: [
                    'The type for the field is invalid',
                    `I would expect ${issue.expected} instead of ${(() => {
                        const i = read(issue, 'input');
                        if (Array.isArray(i))
                            return 'array';
                        if (i === null)
                            return 'null';
                        const t = typeof i;
                        return t === 'object' ? 'object' : t;
                    })()}`,
                ].join('; '),
            };
        }
        case 'invalid_format': {
            return {
                path,
                message: [
                    'The string format for the field is invalid',
                    `${issue.message}`,
                    `Format: ${String(read(issue, 'format') ?? '')}`,
                    read(issue, 'pattern')
                        ? `Pattern: ${String(read(issue, 'pattern'))}`
                        : '',
                ].join('; '),
            };
        }
        case 'invalid_value': {
            return {
                path,
                message: [
                    'The enum for the field is invalid',
                    (() => {
                        const values = read(issue, 'values');
                        return Array.isArray(values)
                            ? `I would expect any of ${values.map((v) => String(v)).join(', ')}`
                            : 'I would expect a valid enum member';
                    })(),
                ].join('; '),
            };
        }
        case 'invalid_union': {
            return {
                path,
                message: [
                    'The union for the field is invalid',
                    (() => {
                        const errors = read(issue, 'errors');
                        const flat = Array.isArray(errors)
                            ? errors.flat(1)
                            : [];
                        const msgs = flat
                            .map((i) => i && typeof i === 'object' && 'message' in i
                            ? String(i.message ?? '')
                            : '')
                            .filter(Boolean)
                            .join(', ');
                        return msgs
                            ? `I would check ${msgs}`
                            : 'I would check individual union branches';
                    })(),
                ].join('; '),
            };
        }
        case 'too_big': {
            return {
                path,
                message: [
                    `The ${String(read(issue, 'origin'))} for the field is too big`,
                    `I would expect the maximum to be ${String(read(issue, 'maximum'))}`,
                ].join('; '),
            };
        }
        case 'too_small': {
            return {
                path,
                message: [
                    `The ${String(read(issue, 'origin'))} for the field is too small`,
                    `I would expect the minimum to be ${String(read(issue, 'minimum'))}`,
                ].join('; '),
            };
        }
        case 'invalid_key': {
            return {
                path,
                message: [
                    `The key for the ${String(read(issue, 'origin'))} is invalid`,
                    (() => {
                        const issues = read(issue, 'issues');
                        const msgs = Array.isArray(issues)
                            ? issues
                                .map((i) => i && typeof i === 'object' && 'message' in i
                                ? String(i.message ?? '')
                                : '')
                                .filter(Boolean)
                                .join(', ')
                            : '';
                        return msgs
                            ? `I would check ${msgs}`
                            : 'I would check the provided key';
                    })(),
                ].join('; '),
            };
        }
        case 'invalid_element': {
            return {
                path,
                message: [
                    `An element for the ${String(read(issue, 'origin'))} is invalid`,
                    `Key: ${JSON.stringify(read(issue, 'key'))}`,
                    (() => {
                        const issues = read(issue, 'issues');
                        const msgs = Array.isArray(issues)
                            ? issues
                                .map((i) => i && typeof i === 'object' && 'message' in i
                                ? String(i.message ?? '')
                                : '')
                                .filter(Boolean)
                                .join(', ')
                            : '';
                        return msgs
                            ? `I would check ${msgs}`
                            : 'I would check the element details';
                    })(),
                ].join('; '),
            };
        }
        case 'not_multiple_of': {
            return {
                path,
                message: [
                    'The value is not a valid multiple',
                    `I would expect a multiple of ${String(read(issue, 'divisor'))}`,
                ].join('; '),
            };
        }
        default: {
            return {
                path,
                message: [
                    'The type for the field is incorrect',
                    `${issue.message}`,
                ].join('; '),
            };
        }
    }
};