PHPackages                             aurynx/http-compression - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [HTTP & Networking](/categories/http)
4. /
5. aurynx/http-compression

ActiveLibrary[HTTP & Networking](/categories/http)

aurynx/http-compression
=======================

Framework-agnostic HTTP compression for PHP (gzip, brotli, zstd) with deterministic builds and safe file precompression.

v0.2.0(7mo ago)04[1 PRs](https://github.com/aurynx/http-compression/pulls)MITPHPPHP ^8.4CI passing

Since Oct 11Pushed 1mo agoCompare

[ Source](https://github.com/aurynx/http-compression)[ Packagist](https://packagist.org/packages/aurynx/http-compression)[ Docs](https://github.com/aurynx/http-compression)[ RSS](/packages/aurynx-http-compression/feed)WikiDiscussions main Synced 1mo ago

READMEChangelogDependencies (3)Versions (4)Used By (0)

Aurynx | HttpCompression
========================

[](#aurynx--httpcompression)

 [![Aurynx Mascot](https://private-user-images.githubusercontent.com/20430159/499389470-80a3ece6-5c50-4b01-9aee-7f086b55a0ef.png?jwt=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJnaXRodWIuY29tIiwiYXVkIjoicmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbSIsImtleSI6ImtleTUiLCJleHAiOjE3NzU0ODA5NzYsIm5iZiI6MTc3NTQ4MDY3NiwicGF0aCI6Ii8yMDQzMDE1OS80OTkzODk0NzAtODBhM2VjZTYtNWM1MC00YjAxLTlhZWUtN2YwODZiNTVhMGVmLnBuZz9YLUFtei1BbGdvcml0aG09QVdTNC1ITUFDLVNIQTI1NiZYLUFtei1DcmVkZW50aWFsPUFLSUFWQ09EWUxTQTUzUFFLNFpBJTJGMjAyNjA0MDYlMkZ1cy1lYXN0LTElMkZzMyUyRmF3czRfcmVxdWVzdCZYLUFtei1EYXRlPTIwMjYwNDA2VDEzMDQzNlomWC1BbXotRXhwaXJlcz0zMDAmWC1BbXotU2lnbmF0dXJlPTM1NDM5YWEwODA5MTk1ZDdiMDlhMmNjNjg2MTZhODc5ZmY1Yzk2YzE3YTA3YmY2ZTVjZDI3MjM0N2U3N2Q0ODYmWC1BbXotU2lnbmVkSGVhZGVycz1ob3N0In0.sL5cXYW9DRH01CBe7IA2Qm2IaL6Ogemcn3tAOTYhDdw)](https://private-user-images.githubusercontent.com/20430159/499389470-80a3ece6-5c50-4b01-9aee-7f086b55a0ef.png?jwt=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJnaXRodWIuY29tIiwiYXVkIjoicmF3LmdpdGh1YnVzZXJjb250ZW50LmNvbSIsImtleSI6ImtleTUiLCJleHAiOjE3NzU0ODA5NzYsIm5iZiI6MTc3NTQ4MDY3NiwicGF0aCI6Ii8yMDQzMDE1OS80OTkzODk0NzAtODBhM2VjZTYtNWM1MC00YjAxLTlhZWUtN2YwODZiNTVhMGVmLnBuZz9YLUFtei1BbGdvcml0aG09QVdTNC1ITUFDLVNIQTI1NiZYLUFtei1DcmVkZW50aWFsPUFLSUFWQ09EWUxTQTUzUFFLNFpBJTJGMjAyNjA0MDYlMkZ1cy1lYXN0LTElMkZzMyUyRmF3czRfcmVxdWVzdCZYLUFtei1EYXRlPTIwMjYwNDA2VDEzMDQzNlomWC1BbXotRXhwaXJlcz0zMDAmWC1BbXotU2lnbmF0dXJlPTM1NDM5YWEwODA5MTk1ZDdiMDlhMmNjNjg2MTZhODc5ZmY1Yzk2YzE3YTA3YmY2ZTVjZDI3MjM0N2U3N2Q0ODYmWC1BbXotU2lnbmVkSGVhZGVycz1ob3N0In0.sL5cXYW9DRH01CBe7IA2Qm2IaL6Ogemcn3tAOTYhDdw)

 **Modern PHP library for HTTP compression with native type safety**

gzip • brotli • zstd — simple, safe, and fast

 [Installation](#installation) • [Quick Start](#quick-start) • [Features](#features) • [Use Cases](#use-cases) • [API](#api-reference) • [Advanced Usage](./docs/advanced-usage.md) • [AI Guide](./docs/AI_GUIDE.md)

---

Why HttpCompression?
--------------------

[](#why-httpcompression)

Modern web applications need efficient compression to reduce bandwidth and improve response times. HttpCompression makes it simple with a clean, modern API focused on:

- 🔷 **Native PHP 8.4+ types** — zero docblock types, full IDE autocomplete
- 🎯 **Single facade pattern** — one intuitive API for all scenarios
- 🚀 **Glob pattern support** — compress entire directories with wildcards
- 💾 **Memory-safe streaming** — handle large files without memory limits
- 🛡️ **Fail-fast validation** — catch errors at configuration time
- 🤖 **AI-friendly design** — perfect for code generation and assistants

Installation
------------

[](#installation)

**Requirements:**

- PHP 8.4 or higher
- `ext-zlib` (required for gzip)
- `ext-brotli` (optional, for brotli compression)
- `ext-zstd` (optional, for zstd compression)

```
composer require aurynx/http-compression
```

Quick Start
-----------

[](#quick-start)

### Single File Compression

[](#single-file-compression)

```
use Aurynx\HttpCompression\CompressorFacade;
use Aurynx\HttpCompression\Enums\AlgorithmEnum;

// Compress and save to file
CompressorFacade::once()
    ->file('public/index.html')
    ->withGzip(9)
    ->saveTo('public/index.html.gz');

// Compress in-memory data
$html = 'Hello World';
$result = CompressorFacade::once()
    ->data($html)
    ->withBrotli(11)
    ->compress();

$compressed = $result->getData(AlgorithmEnum::Brotli);
```

### Batch Compression

[](#batch-compression)

```
use Aurynx\HttpCompression\CompressorFacade;
use Aurynx\HttpCompression\ValueObjects\ItemConfig;

$result = CompressorFacade::make()
    ->addGlob('public/**/*.{html,css,js}')
    ->withDefaultConfig(
        ItemConfig::create()
            ->withGzip(9)
            ->withBrotli(11)
            ->build()
    )
    ->skipAlreadyCompressed()
    ->toDir('./dist')
    ->compress();

echo "Compressed {$result->count()} files\n";
echo "Success rate: " . ($result->allOk() ? '100%' : 'partial') . "\n";
```

Features
--------

[](#features)

### ✨ Native Type Safety

[](#-native-type-safety)

The public API uses native PHP 8.4+ types everywhere (parameters, return types, readonly DTOs). This makes the library:

- Easier for IDEs and AI agents to navigate (no docblock type guessing)
- Safer at runtime thanks to engine-level type checks
- More self-documenting due to explicit signatures

Example signature:

```
public function compress(ItemConfig $config): CompressionResult
```

---

### 🎯 Fluent Facade API

[](#-fluent-facade-api)

Two facades for different scenarios:

#### `CompressorFacade::make()` — Batch compression

[](#compressorfacademake--batch-compression)

```
CompressorFacade::make()
    ->addFile('index.html')
    ->addGlob('assets/*.css')
    ->withDefaultConfig(ItemConfig::create()->withGzip(9)->build())
    ->toDir('./output')
    ->compress();
```

#### `CompressorFacade::once()` — Quick single-item tasks

[](#compressorfacadeonce--quick-single-item-tasks)

```
CompressorFacade::once()
    ->file('logo.svg')
    ->withGzip(9)
    ->saveTo('logo.svg.gz');
```

---

### 🚀 Glob Pattern Support

[](#-glob-pattern-support)

Compress entire directories with powerful glob patterns:

```
CompressorFacade::make()
    ->addGlob('public/**/*.html')           // All HTML files recursively
    ->addGlob('assets/*.{css,js}')          // CSS and JS in assets/
    ->addGlob('fonts/*.woff2')              // Specific extension
    ->skipAlreadyCompressed()               // Skip images, videos, etc.
    ->toDir('./dist', keepStructure: true)
    ->compress();
```

---

### 💾 Memory-Safe Streaming

[](#-memory-safe-streaming)

Handle large files without loading into memory:

```
use Aurynx\HttpCompression\ValueObjects\OutputConfig;

$result = CompressorFacade::make()
    ->addFile('large-file.json')  // 500MB file
    ->withDefaultConfig(ItemConfig::create()->withGzip(6)->build())
    ->inMemory(maxBytes: 100_000_000)  // 100MB limit
    ->compress();

// Stream compressed data
$result->first()->read(AlgorithmEnum::Gzip, function (string $chunk) {
    echo $chunk;  // Process in chunks
});
```

---

### 🔌 Callback Streaming (no resources)

[](#-callback-streaming-no-resources)

Stream compressed data directly into callbacks without dealing with stream resources.

Single algorithm (sendToCallback):

```
use Aurynx\HttpCompression\CompressorFacade;

$buffer = '';
CompressorFacade::once()
    ->data(str_repeat('hello ', 5000))
    ->withGzip(6)
    ->sendToCallback(function (string $chunk) use (&$buffer): void {
        $buffer .= $chunk; // write to socket, PSR-7 body, etc.
    });
```

Multiple algorithms (sendAllToCallbacks):

```
use Aurynx\HttpCompression\CompressorFacade;

$gz = '';
CompressorFacade::once()
    ->data('payload')
    ->withGzip(6)      // required by default
    ->tryBrotli(4)     // optional
    ->sendAllToCallbacks([
        'gzip' => static function (string $chunk) use (&$gz): void {
            $gz .= $chunk;
        },
        // 'br' may be omitted when added via tryBrotli()
    ]);
```

See more patterns and caveats in Advanced Usage:

- Callback streaming (single/multi)
- Low-level WritableStream wrapper

👉 Read: ./docs/advanced-usage.md

---

### 🛡️ Fail-Fast Validation

[](#️-fail-fast-validation)

Errors are caught at configuration time, not during compression:

```
// ❌ Throws immediately (invalid level)
AlgorithmSet::gzip(99);  // InvalidArgumentException: Level must be between 1 and 9

// ❌ Throws immediately (multiple algorithms for saveTo)
CompressorFacade::once()
    ->file('test.txt')
    ->withGzip(9)
    ->withBrotli(11)  // Multiple algorithms
    ->saveTo('test.gz');  // CompressionException: saveTo() requires exactly one algorithm
```

---

### 📈 Rich Result Objects

[](#-rich-result-objects)

Detailed statistics and easy access:

```
$result = CompressorFacade::make()
    ->addGlob('*.html')
    ->withDefaultConfig(ItemConfig::create()->withGzip(9)->withBrotli(11)->build())
    ->inMemory()
    ->compress();

// Access results
foreach ($result as $id => $item) {
    if ($item->isOk()) {
        echo "Original: {$item->originalSize} bytes\n";
        echo "Gzip: {$item->compressedSizes['gzip']} bytes\n";
        echo "Brotli: {$item->compressedSizes['brotli']} bytes\n";
    }
}

// Aggregated statistics
$summary = $result->summary();
echo "Median compression ratio (gzip): " . $summary->getMedianRatio(AlgorithmEnum::Gzip) . "\n";
echo "P95 compression time (brotli): " . $summary->getP95TimeMs(AlgorithmEnum::Brotli) . " ms\n";
```

---

Use Cases
---------

[](#use-cases)

### 1. Static Site Pre-Compression

[](#1-static-site-pre-compression)

Compress assets during build for nginx `gzip_static`:

```
use Aurynx\HttpCompression\CompressorFacade;
use Aurynx\HttpCompression\ValueObjects\ItemConfig;

// Build script
$result = CompressorFacade::make()
    ->addGlob('dist/**/*.{html,css,js,svg,json}')
    ->withDefaultConfig(
        ItemConfig::create()
            ->withGzip(9)
            ->withBrotli(11)
            ->build()
    )
    ->skipAlreadyCompressed()
    ->toDir('./dist', keepStructure: true)
    ->compress();

if (!$result->allOk()) {
    foreach ($result->failures() as $id => $failure) {
        echo "Failed: {$id} - {$failure->getFailureReason()?->getMessage()}\n";
    }
    exit(1);
}

echo "✓ Compressed {$result->count()} files\n";
```

**Nginx configuration:**

```
gzip_static on;
brotli_static on;
```

---

### 2. Dynamic HTTP Response Compression

[](#2-dynamic-http-response-compression)

Compress content on-the-fly with caching:

```
use Aurynx\HttpCompression\CompressorFacade;
use Aurynx\HttpCompression\AlgorithmEnum;

function compressResponse(string $content, string $acceptEncoding): string
{
    $cacheKey = 'compressed_' . md5($content) . '_' . $acceptEncoding;

    if ($cached = apcu_fetch($cacheKey)) {
        return $cached;
    }

    $algo = str_contains($acceptEncoding, 'br') ? AlgorithmEnum::Brotli : AlgorithmEnum::Gzip;

    $result = CompressorFacade::once()
        ->data($content)
        ->withAlgorithm($algo, $algo->getDefaultLevel())
        ->compress();

    $compressed = $result->getData($algo);
    apcu_store($cacheKey, $compressed, 3600);

    return $compressed;
}

// In your controller
$html = view('welcome')->render();
$acceptEncoding = $_SERVER['HTTP_ACCEPT_ENCODING'] ?? '';

if (str_contains($acceptEncoding, 'br') || str_contains($acceptEncoding, 'gzip')) {
    $compressed = compressResponse($html, $acceptEncoding);
    header('Content-Encoding: ' . (str_contains($acceptEncoding, 'br') ? 'br' : 'gzip'));
    echo $compressed;
} else {
    echo $html;
}
```

---

### 3. API Response Compression

[](#3-api-response-compression)

Compress JSON API responses:

```
use Aurynx\HttpCompression\CompressorFacade;
use Aurynx\HttpCompression\AlgorithmEnum;

function compressApiResponse(array $data, string $acceptEncoding): string
{
    $json = json_encode($data);

    if (!str_contains($acceptEncoding, 'gzip')) {
        return $json;
    }

    $result = CompressorFacade::once()
        ->data($json)
        ->withGzip(6)  // Lower level for speed
        ->compress();

    header('Content-Encoding: gzip');
    header('Vary: Accept-Encoding');

    return $result->getData(AlgorithmEnum::Gzip);
}

// Usage
$data = ['users' => User::all()];
echo compressApiResponse($data, $_SERVER['HTTP_ACCEPT_ENCODING'] ?? '');
```

---

### 4. Log File Archival

[](#4-log-file-archival)

Compress and archive old log files:

```
use Aurynx\HttpCompression\CompressorFacade;
use Aurynx\HttpCompression\ValueObjects\ItemConfig;

// Daily cron job
$result = CompressorFacade::make()
    ->addGlob('storage/logs/*.log')
    ->withDefaultConfig(ItemConfig::create()->withZstd(19)->build())  // Maximum compression
    ->toDir('storage/logs/archive', keepStructure: false)
    ->compress();

// Delete originals
foreach ($result->successes() as $id => $item) {
    $originalPath = "storage/logs/{$id}";
    if (file_exists($originalPath)) {
        unlink($originalPath);
    }
}

echo "Archived {$result->count()} log files\n";
```

---

### 5. Asset Pipeline Integration

[](#5-asset-pipeline-integration)

Integrate with your build tools:

```
use Aurynx\HttpCompression\CompressorFacade;
use Aurynx\HttpCompression\ValueObjects\ItemConfig;

class AssetCompiler
{
    public function compile(): void
    {
        // Step 1: Bundle and minify (webpack, vite, etc.)
        system('npm run build');

        // Step 2: Compress for production
        $result = CompressorFacade::make()
            ->addGlob('public/build/**/*.{js,css}')
            ->addGlob('public/build/**/*.{svg,json}')
            ->withDefaultConfig(
                ItemConfig::create()
                    ->withGzip(9)
                    ->withBrotli(11)
                    ->build()
            )
            ->skipExtensions(['woff2', 'png', 'jpg'])
            ->toDir('public/build', keepStructure: true)
            ->failFast(true)
            ->compress();

        if (!$result->allOk()) {
            throw new \RuntimeException('Asset compression failed');
        }

        $summary = $result->summary();
        $avgRatio = $summary->getAverageRatio(AlgorithmEnum::Gzip);
        echo "✓ Compressed {$result->count()} assets (avg ratio: " . round($avgRatio * 100, 1) . "%)\n";
    }
}
```

---

API Reference
-------------

[](#api-reference)

### Facades

[](#facades)

#### `CompressorFacade::make()` — Batch Compression

[](#compressorfacademake--batch-compression-1)

```
use Aurynx\HttpCompression\CompressorFacade;

$result = CompressorFacade::make()
    // Add inputs
    ->add(CompressionInput $input, ?ItemConfig $config = null)
    ->addMany(iterable $inputs)
    ->addFile(string $path, ?ItemConfig $config = null, ?string $id = null)
    ->addData(string $data, ?ItemConfig $config = null, ?string $id = null)
    ->addGlob(string $pattern, ?ItemConfig $config = null)
    ->addFrom(InputProviderInterface $provider, ?ItemConfig $config = null)

    // Configuration
    ->withDefaultConfig(ItemConfig $config)

    // Output
    ->toDir(string $dir, bool $keepStructure = false)
    ->inMemory(int $maxBytes = 5_000_000)

    // Options
    ->failFast(bool $enable = true)
    ->skipExtensions(array $extensions)
    ->skipAlreadyCompressed()

    // Execute
    ->compress(): CompressionResult;
```

#### `CompressorFacade::once()` — Single Item

[](#compressorfacadeonce--single-item)

```
use Aurynx\HttpCompression\CompressorFacade;

CompressorFacade::once()
    // Input
    ->file(string $path)
    ->data(string $data)

    // Algorithm (choose ONE)
    ->withGzip(int $level = 6)
    ->withBrotli(int $level = 11)
    ->withZstd(int $level = 3)

    // Execute
    ->compress(): CompressionItemResult
    ->saveTo(string $path): void;  // Requires exactly one algorithm
```

---

Notes on Saving Files
---------------------

[](#notes-on-saving-files)

- saveTo(path):

    - Atomic write (tmp + rename) to the target path
    - Existing target is replaced (OverwritePolicy=Replace)
    - The target directory must already exist (no auto-create)
- saveAllTo(directory, basename, options):

    - basename must be a plain filename (no '/' or '\\', not '.' or '..')
    - Options:
        - overwritePolicy: fail|replace|skip (default fail)
        - atomicAll: bool (default true) — all-or-nothing semantics
        - allowCreateDirs: bool (default true)
        - permissions: int|null — chmod after successful rename

---

### Configuration

[](#configuration)

#### `ItemConfig` — Compression Configuration

[](#itemconfig--compression-configuration)

```
use Aurynx\HttpCompression\ValueObjects\ItemConfig;
use Aurynx\HttpCompression\ValueObjects\AlgorithmSet;

// Using builder
$config = ItemConfig::create()
    ->withGzip(9)
    ->withBrotli(11)
    ->withZstd(3)
    ->limitBytes(5_000_000)
    ->build();

// Direct instantiation
$config = new ItemConfig(
    algorithms: AlgorithmSet::gzip(9),
    maxBytes: 1_000_000
);

// Static factories
$config = ItemConfig::gzip(9);
$config = ItemConfig::brotli(11);
$config = ItemConfig::zstd(3);
```

#### `AlgorithmSet` — Algorithm Configuration

[](#algorithmset--algorithm-configuration)

```
use Aurynx\HttpCompression\ValueObjects\AlgorithmSet;
use Aurynx\HttpCompression\Enums\AlgorithmEnum;

// Static factories
$set = AlgorithmSet::gzip(9);
$set = AlgorithmSet::brotli(11);
$set = AlgorithmSet::zstd(3);
$set = AlgorithmSet::fromDefaults();  // All algorithms with default levels

// Manual construction from pairs
$set = AlgorithmSet::from([
    [AlgorithmEnum::Gzip, 9],
    [AlgorithmEnum::Brotli, 11],
]);
```

---

### Results

[](#results)

#### `CompressionResult` — Batch Results

[](#compressionresult--batch-results)

```
$result = CompressorFacade::make()->compress();

// Access
$result->get(string $id): CompressionItemResult
$result->first(): CompressionItemResult
$result->toArray(): array

// Filtering
$result->successes(): array
$result->failures(): array
$result->allOk(): bool

// Statistics
$result->summary(): CompressionSummaryResult
$result->count(): int

// Iteration
foreach ($result as $id => $item) {
    // Process each item
}
```

#### `CompressionItemResult` — Single Item Result

[](#compressionitemresult--single-item-result)

```
$item = $result->first();

// Status
$item->isOk(): bool
$item->success: bool
$item->originalSize: int

// Data access
$item->getData(AlgorithmEnum $algo): string
$item->getStream(AlgorithmEnum $algo): resource
$item->read(AlgorithmEnum $algo, callable $consumer): void

// Metadata
$item->has(AlgorithmEnum $algo): bool
$item->compressedSizes: array
$item->compressionTimes: array
$item->errors: array
$item->getFailureReason(): ?\Throwable
```

#### `CompressionSummaryResult` — Aggregated Statistics

[](#compressionsummaryresult--aggregated-statistics)

```
$summary = $result->summary();

// Compression ratios (compressed / original)
$summary->getAverageRatio(AlgorithmEnum $algo): float
$summary->getMedianRatio(AlgorithmEnum $algo): float  // p50
$summary->getP95Ratio(AlgorithmEnum $algo): float

// Timing (milliseconds)
$summary->getMedianTimeMs(AlgorithmEnum $algo): float  // p50
$summary->getP95TimeMs(AlgorithmEnum $algo): float
$summary->getTotalTimeMs(AlgorithmEnum $algo): float

// Counts
$summary->getTotalItems(): int
$summary->getSuccessCount(): int
$summary->getFailureCount(): int
```

---

For AI Assistants
-----------------

[](#for-ai-assistants)

This library is designed to be AI-friendly with:

- ✅ **Native types** — no docblock parsing needed
- ✅ **Explicit naming** — `CompressionResult`, `AlgorithmEnum`, etc.
- ✅ **Fluent API** — easy to chain methods
- ✅ **Fail-fast** — errors are obvious and immediate
- ✅ **Immutable value objects** — no side effects

For a deeper, agent-focused walkthrough, see the AI Guide: [AI\_GUIDE.md](./docs/AI_GUIDE.md). You can also use the machine-readable schema [`docs/ai-manifest.json`](docs/ai-manifest.json).

### Common Patterns

[](#common-patterns)

```
// Quick compression
CompressorFacade::once()->file('test.txt')->withGzip(9)->saveTo('test.txt.gz');

// Batch with glob
CompressorFacade::make()
    ->addGlob('*.html')
    ->withDefaultConfig(ItemConfig::create()->withGzip(9)->build())
    ->toDir('./out')
    ->compress();

// Multiple algorithms
$config = ItemConfig::create()
    ->withGzip(9)
    ->withBrotli(11)
    ->withZstd(3)
    ->build();
```

### Avoid These Mistakes

[](#avoid-these-mistakes)

❌ Multiple algorithms with `saveTo()`:

```
// WRONG - saveTo() requires exactly one algorithm
CompressorFacade::once()->file('x')->withGzip()->withBrotli()->saveTo('x.gz');
```

✅ Use `compress()` instead:

```
$result = CompressorFacade::once()->file('x')->withGzip()->withBrotli()->compress();
$result->getData(AlgorithmEnum::Gzip);
```

---

Contributing
------------

[](#contributing)

Contributions are welcome! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for details.

### Development Setup

[](#development-setup)

```
# Install dependencies
composer install

# Run tests
composer test

# Run PHPStan
composer phpstan

# Run CS Fixer
composer cs-fix
```

---

License
-------

[](#license)

The MIT License (MIT). Please see [License File](LICENSE) for more information.

---

Credits
-------

[](#credits)

Created and maintained by [Anton Semenov](mailto:anton.a.semenov@proton.me).

---

Crafted by Aurynx 🔮

###  Health Score

36

—

LowBetter than 82% of packages

Maintenance81

Actively maintained with recent releases

Popularity3

Limited adoption so far

Community8

Small or concentrated contributor base

Maturity45

Maturing project, gaining track record

 Bus Factor1

Top contributor holds 89.6% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Unknown

Total

1

Last Release

210d ago

### Community

Maintainers

![](https://www.gravatar.com/avatar/470711e2159b826fffa9932f25b6dc45eda94388f25d3265ef9570a9d8050add?d=identicon)[trydalcoholic](/maintainers/trydalcoholic)

---

Top Contributors

[![trydalcoholic](https://avatars.githubusercontent.com/u/20430159?v=4)](https://github.com/trydalcoholic "trydalcoholic (69 commits)")[![dependabot[bot]](https://avatars.githubusercontent.com/in/29110?v=4)](https://github.com/dependabot[bot] "dependabot[bot] (8 commits)")

---

Tags

aurynxbrotlicontent-encodinggziphttp-compressionlibrarynginxoptimizationperformancephpstatic-assetszstdhttpphpcompressioncompressorstaticnginxbrgzipbrotlizstdcontent-encodingaurynx

###  Code Quality

TestsPest

Static AnalysisPHPStan

Code StylePHP CS Fixer

Type Coverage Yes

### Embed Badge

![Health badge](/badges/aurynx-http-compression/health.svg)

```
[![Health](https://phpackages.com/badges/aurynx-http-compression/health.svg)](https://phpackages.com/packages/aurynx-http-compression)
```

###  Alternatives

[hannesvdvreken/guzzle-debugbar

A Guzzle middleware that logs requests to debugbar's timeline

76410.4k1](/packages/hannesvdvreken-guzzle-debugbar)[swoole-bundle/swoole-bundle

Open/Swoole Symfony Bundle

6650.4k](/packages/swoole-bundle-swoole-bundle)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)