@middy/http-response-serializer/index.cjs

The Http Serializer middleware lets you define serialization mechanisms based on the current content negotiation.

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
Object.defineProperty(module, "exports", {
    enumerable: true,
    get: ()=>_default
});
const _util = require("@middy/util");
const _accept = _interopRequireDefault(require("@hapi/accept"));
function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
        default: obj
    };
}
const defaults = {
    serializers: [],
    defaultContentType: undefined
};
const httpResponseSerializerMiddleware = (opts = {})=>{
    const { serializers , defaultContentType  } = {
        ...defaults,
        ...opts
    };
    const httpResponseSerializerMiddlewareAfter = async (request)=>{
        (0, _util.normalizeHttpResponse)(request);
        if (request.response.headers['Content-Type']) return;
        let types;
        if (request.event.requiredContentType) {
            types = [
                request.event.requiredContentType
            ];
        } else {
            const acceptHeader = request.event.headers.Accept ?? request.event.headers.accept;
            types = [
                ...(acceptHeader && _accept.default.mediaTypes(acceptHeader)) ?? [],
                request.event.preferredContentType,
                defaultContentType
            ];
        }
        for (const type of types){
            let breakTypes;
            for (const s of serializers){
                if (!s.regex.test(type)) {
                    continue;
                }
                request.response.headers['Content-Type'] = type;
                const result = s.serializer(request.response);
                if (typeof result === 'object' && 'body' in result) {
                    request.response = result;
                } else {
                    request.response.body = result;
                }
                breakTypes = true;
                break;
            }
            if (breakTypes) break;
        }
    };
    const httpResponseSerializerMiddlewareOnError = async (request)=>{
        if (request.response === undefined) return;
        return httpResponseSerializerMiddlewareAfter(request);
    };
    return {
        after: httpResponseSerializerMiddlewareAfter,
        onError: httpResponseSerializerMiddlewareOnError
    };
};
const _default = httpResponseSerializerMiddleware;


//# sourceMappingURL=index.cjs.map