compressionMiddleware function

Middleware compressionMiddleware(CompressionOptionsResolver resolver)

Implementation

Middleware compressionMiddleware(CompressionOptionsResolver resolver) {
  return (ctx, next) async {
    final options = resolver();
    if (!options.enabled) {
      return await next();
    }

    if (ctx.request.getAttribute<bool>(compressionSkipAttribute) == true) {
      return await next();
    }

    final negotiation = _negotiateEncoding(ctx, options);
    if (negotiation == null) {
      return await next();
    }

    _ensureVaryHeader(ctx);

    ctx.response.setBodyFilter((body) {
      if (ctx.request.getAttribute<bool>(compressionSkipAttribute) == true) {
        return body;
      }

      if (ctx.response.statusCode < 200 ||
          ctx.response.statusCode == HttpStatus.noContent ||
          ctx.response.statusCode == HttpStatus.resetContent ||
          ctx.response.statusCode == HttpStatus.notModified ||
          ctx.request.method == 'HEAD' ||
          body.isEmpty) {
        return body;
      }

      final existingEncoding = ctx.response.headers.value(
        HttpHeaders.contentEncodingHeader,
      );
      if (existingEncoding != null && existingEncoding.isNotEmpty) {
        return body;
      }

      final mimeType =
          ctx.response.headers.contentType?.mimeType ??
          ctx.response.headers.value(HttpHeaders.contentTypeHeader) ??
          'text/plain';
      if (!options.isMimeAllowed(mimeType)) {
        return body;
      }

      if (body.length < options.minLength) {
        return body;
      }

      ctx.response.removeHeader(HttpHeaders.contentLengthHeader);
      ctx.response.headers.set(
        HttpHeaders.contentEncodingHeader,
        negotiation.headerValue,
      );

      return negotiation.encode(body);
    });

    return await next();
  };
}