"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
Object.defineProperty(module, "exports", {
    enumerable: true,
    get: ()=>_default
});
const _util = require("@middy/util");
const _2020Js = _interopRequireDefault(require("ajv/dist/2020.js"));
const _ajvI18N = _interopRequireDefault(require("ajv-i18n"));
const _ajvFormats = _interopRequireDefault(require("ajv-formats"));
const _ajvFormatsDraft2019 = _interopRequireDefault(require("ajv-formats-draft2019"));
const _typeofJs = _interopRequireDefault(require("ajv-keywords/dist/definitions/typeof.js"));
const _fastUri = _interopRequireDefault(require("fast-uri"));
function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
        default: obj
    };
}
const Ajv = _2020Js.default.default;
let ajv;
const ajvDefaults = {
    strict: true,
    coerceTypes: 'array',
    allErrors: true,
    useDefaults: 'empty',
    messages: false,
    uriResolver: _fastUri.default,
    keywords: [
        (0, _typeofJs.default)()
    ]
};
const defaults = {
    eventSchema: undefined,
    contextSchema: undefined,
    responseSchema: undefined,
    ajvOptions: {},
    ajvInstance: undefined,
    defaultLanguage: 'en',
    i18nEnabled: true
};
const validatorMiddleware = (opts = {})=>{
    let { inputSchema , outputSchema , eventSchema , contextSchema , responseSchema , ajvOptions , ajvInstance , defaultLanguage , i18nEnabled  } = {
        ...defaults,
        ...opts
    };
    eventSchema = compile(eventSchema ?? inputSchema, ajvOptions, ajvInstance);
    contextSchema = compile(contextSchema, ajvOptions, ajvInstance);
    responseSchema = compile(responseSchema ?? outputSchema, ajvOptions, ajvInstance);
    const validatorMiddlewareBefore = async (request)=>{
        if (eventSchema) {
            const validEvent = await eventSchema(request.event);
            if (!validEvent) {
                if (i18nEnabled) {
                    const language = chooseLanguage(request.event, defaultLanguage);
                    _ajvI18N.default[language](eventSchema.errors);
                }
                const error = (0, _util.createError)(400, 'Event object failed validation');
                error.cause = eventSchema.errors;
                throw error;
            }
        }
        if (contextSchema) {
            const validContext = await contextSchema(request.context);
            if (!validContext) {
                const error1 = (0, _util.createError)(500, 'Context object failed validation');
                error1.cause = contextSchema.errors;
                throw error1;
            }
        }
    };
    const validatorMiddlewareAfter = async (request)=>{
        const valid = await responseSchema(request.response);
        if (!valid) {
            const error = (0, _util.createError)(500, 'Response object failed validation');
            error.cause = responseSchema.errors;
            throw error;
        }
    };
    return {
        before: eventSchema ?? inputSchema ?? contextSchema ? validatorMiddlewareBefore : undefined,
        after: responseSchema ?? outputSchema ? validatorMiddlewareAfter : undefined
    };
};
const compile = (schema, ajvOptions, ajvInstance = null)=>{
    if (typeof schema === 'function' || !schema) return schema;
    const options = {
        ...ajvDefaults,
        ...ajvOptions
    };
    if (!ajv) {
        ajv = ajvInstance ?? new Ajv(options);
        (0, _ajvFormats.default)(ajv);
        (0, _ajvFormatsDraft2019.default)(ajv);
    } else if (!ajvInstance) {
        ajv.opts = {
            ...ajv.opts,
            ...options
        };
    }
    return ajv.compile(schema);
};
const languageNormalizationMap = {
    pt: 'pt-BR',
    'pt-br': 'pt-BR',
    pt_BR: 'pt-BR',
    pt_br: 'pt-BR',
    'zh-tw': 'zh-TW',
    zh_TW: 'zh-TW',
    zh_tw: 'zh-TW'
};
const normalizePreferredLanguage = (lang)=>languageNormalizationMap[lang] ?? lang;
const availableLanguages = Object.keys(_ajvI18N.default);
const chooseLanguage = ({ preferredLanguage  }, defaultLanguage)=>{
    if (preferredLanguage) {
        const lang = normalizePreferredLanguage(preferredLanguage);
        if (availableLanguages.includes(lang)) {
            return lang;
        }
    }
    return defaultLanguage;
};
const _default = validatorMiddleware;


//# sourceMappingURL=index.cjs.map