XyPriss Compression

Custom compression middleware for Express/Connect with strict algorithm enforcement.

Key Feature

Unlike the standard compression package, xypriss-compression enforces which compression algorithms can be used. If you configure algorithms: ['br', 'deflate'], it will never use gzip, even if the client requests it.

Problem Solved

The original compression package has no way to restrict which algorithms are used. It automatically chooses based on the client's Accept-Encoding header, ignoring your configuration.

Example of the problem:

// Using standard 'compression' package
const compression = require("compression");
app.use(
  compression({
    // This option doesn't exist!
    // algorithms: ['br', 'deflate']
  })
);

// Client requests gzip → Server uses gzip (no control!)

With xypriss-compression:

import compression from "xypriss-compression-pluging";

app.use(
  compression({
    algorithms: ["br", "deflate"], // STRICTLY ENFORCED
  })
);

// Client requests gzip → Server responds with identity (uncompressed)
// Client requests br → Server uses brotli
// Client requests deflate → Server uses deflate

Installation

npm install xypriss-compression

Usage

Basic Usage

import express from "express";
import compression from "xypriss-compression-pluging";

const app = express();

// Use with default settings (gzip, deflate)
app.use(compression());

app.listen(3000);

With Algorithm Enforcement

import compression from "xypriss-compression-pluging";

app.use(
  compression({
    // Only allow Brotli and Deflate
    algorithms: ["br", "deflate"],

    // Compression level (1-9 for gzip/deflate, 0-11 for brotli)
    level: 6,

    // Minimum size to compress (1KB)
    threshold: "1kb",
  })
);

Advanced Configuration

app.use(
  compression({
    algorithms: ["br", "gzip"],
    level: 9,
    threshold: 2048,

    // Custom filter
    filter: (req, res) => {
      // Don't compress images
      const type = res.getHeader("Content-Type");
      if (type && type.toString().startsWith("image/")) {
        return false;
      }
      return true;
    },

    // Brotli-specific options
    brotli: {
      params: {
        [zlib.constants.BROTLI_PARAM_MODE]: zlib.constants.BROTLI_MODE_TEXT,
      },
    },

    // Gzip-specific options
    gzip: {
      memLevel: 8,
    },
  })
);

API

compression(options?)

Creates a compression middleware.

Options

Option	Type	Default	Description
algorithms	Array<'gzip' | 'deflate' | 'br'>	['gzip', 'deflate']	Strictly enforced list of allowed algorithms
level	number	6	Compression level (1-9 for gzip/deflate, 0-11 for brotli)
threshold	number | string	1024	Minimum response size to compress
filter	Function	shouldCompress	Custom filter function
brotli	BrotliOptions	{}	Brotli-specific options
gzip	ZlibOptions	{}	Gzip-specific options
deflate	ZlibOptions	{}	Deflate-specific options

How It Works

1. Client sends request with Accept-Encoding: gzip, deflate, br
2. Middleware checks which algorithms are in the algorithms config
3. Selects best match from allowed algorithms (priority: br > gzip > deflate)
4. If no match, responds with uncompressed data (identity)

Algorithm Selection Priority

When multiple algorithms are allowed and accepted by the client:

1. Brotli (br) - Best compression ratio
2. Gzip (gzip) - Good compression, widely supported
3. Deflate (deflate) - Faster but less efficient

Comparison with compression

Feature	compression	xypriss-compression
Algorithm enforcement	No	Yes
TypeScript	No	Yes
Custom filters	Yes	Yes
Threshold	Yes	Yes
Brotli support	Yes	Yes

Use Cases

Security Compliance

// Only use approved algorithms
app.use(
  compression({
    algorithms: ["br"], // Company policy: Brotli only
  })
);

Performance Optimization

// Prefer speed over compression ratio
app.use(
  compression({
    algorithms: ["deflate"], // Fastest
    level: 1,
  })
);

Modern Browsers Only

// Serve Brotli to modern browsers, nothing to old ones
app.use(
  compression({
    algorithms: ["br"],
    filter: (req, res) => {
      // Fallback to uncompressed for old browsers
      return req.headers["user-agent"]?.includes("Chrome") || false;
    },
  })
);

Debugging

Enable debug logs:

DEBUG=xypriss:compression node app.js

License

MIT

Author

Nehonix Team

• Website: nehonix.com
• GitHub: @Nehonix-Team

Credits

Based on expressjs/compression but with strict algorithm enforcement.

Links

• GitHub Repository
• Issue Tracker
• XyPriss Framework