init commit

Author: charjr

.github/workflows/ci.yml

@@ -0,0 +1,11 @@
+name: "Continuous Integration"
+
+on:
+  pull_request:
+  push:
+    branches:
+    tags:
+
+jobs:
+  ci:
+    uses: laminas/workflow-continuous-integration/.github/workflows/[email protected]

.gitignore

@@ -0,0 +1,5 @@
+vendor
+.idea
+composer.lock
+composer.phar
+.phpunit.cache

.laminas-ci.json

@@ -0,0 +1,13 @@
+{
+  "additional_checks": [
+    {
+      "name": "PHPStan",
+      "job": {
+        "php": "*",
+        "dependencies": "*",
+        "command": "vendor/bin/phpstan analyse"
+      }
+    }
+  ],
+  "stablePHP": "8.0"
+}

README.md

@@ -0,0 +1,75 @@
+# Laravel Content Encoding Middleware
+
+## About
+
+Middleware that encodes response content.
+
+Reduces data sent out, reduces bandwidth used.
+
+## Installation
+
+Require the `` package in your composer.json and update your dependencies:
+
+## Configuration
+
+The defaults are set in `config/content-encoding.php`.  
+To publish a copy to your own config, use the following:
+
+```text
+php artisan vendor:publish --tag="green-turtle-content-encoding"
+```
+
+### Encode Unknown Types
+
+Sometimes the `Content-Type` header may be missing.
+You may specify in your config whether you still wish to try encoding data.
+
+By default, it is set to false.
+
+```php
+'encode_unknown_type' => false,
+```
+
+### Allowed Types
+
+These are the types of content allowed to be encoded.  
+Each type is a string that will be used as a regex pattern.
+
+Example, any text format is acceptable:
+
+```php
+'allowed_types' => [ '#^(text\/.*)(;.*)?$#' ]
+```
+
+#### Encoders
+
+These are the encoders determine what encodings are supported.
+
+The built-in Encoders are enabled by default:
+
+```php
+'encoders' => [
+    Gzip::class,
+    Deflate::class,
+]
+```
+
+You may create more by implementing the following interface:
+
+```text
+GreenTurtle\Middleware\Encoder\ContentEncoder
+```
+
+## Global Usage
+
+To enable this middleware globally, add the following to your `middleware` array, found within  `app/Http/Kernel.php`:
+
+For example:
+
+```php
+protected $middleware = [
+  // other middleware...
+  \GreenTurtle\Middleware\ContentEncoding::class
+  // other middleware...
+];
+```

composer.json

@@ -0,0 +1,34 @@
+{
+  "name": "green-turtle/content-encoding",
+  "type": "library",
+  "autoload": {
+    "psr-4": {
+      "GreenTurtle\\Middleware\\": "src/"
+    }
+  },
+  "autoload-dev": {
+    "psr-4": {
+      "GreenTurtle\\Middleware\\Tests\\": "tests/",
+      "GreenTurtle\\Middleware\\Tests\\Fixtures\\": "tests/Fixtures"
+    }
+  },
+  "require": {
+    "php": "^8.1.0",
+    "ext-zlib": "*",
+    "illuminate/http": "^9.0 || ^10.0",
+    "illuminate/support": "^9.0 || ^10.0",
+    "symfony/psr-http-message-bridge": "^2.1"
+  },
+  "require-dev": {
+    "phpstan/phpstan": "^1.10",
+    "phpunit/phpunit": "^10.5",
+    "squizlabs/php_codesniffer": "^3.7"
+  },
+  "extra": {
+    "laravel": {
+      "providers": [
+        "GreenTurtle\\Middleware\\ServiceProvider"
+      ]
+    }
+  }
+}

config/content-encoding.php

@@ -0,0 +1,49 @@
+<?php
+
+declare(strict_types=1);
+
+use GreenTurtle\Middleware\Encoder;
+
+return [
+    /*
+    |--------------------------------------------------------------------------
+    | Encode Unknown Content Type
+    |--------------------------------------------------------------------------
+    |
+    | A boolean value
+    | false ~ Do not encode if the 'Content-Type' header is missing
+    | true ~ Try to encode when the 'Content-Type' header is missing
+    */
+    'encode_unknown_type' => false,
+
+    /*
+    |--------------------------------------------------------------------------
+    | Allowed Content Types
+    |--------------------------------------------------------------------------
+    |
+    | An array of string regex patterns
+    | Specifies the content types allowed for encoding
+    | Any content type that matches one of the regex patterns is allowed
+    |
+    */
+    'allowed_types' => [
+        '#^(text\/.*)(;.*)?$#',
+        '#^(image\/svg\\+xml)(;.*)?$#',
+        '#^(application\/json)(;.*)?$#',
+    ],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Content Encoders
+    |--------------------------------------------------------------------------
+    |
+    | An array of ContentEncoder implementations
+    | Specifies which encodings are available to the middleware
+    | The order determines which available encodings take priority
+    |
+    */
+    'encoders' => [
+        Encoder\Gzip::class,
+        Encoder\Deflate::class,
+    ],
+];

phpcs.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<ruleset name="PSR">
+    <description>PHPCS configuration file.</description>
+    <file>src</file>
+
+    <exclude-pattern>*/vendor/*</exclude-pattern>
+
+    <rule ref="PSR1"/>
+    <rule ref="PSR12"/>
+</ruleset>

phpstan.neon

@@ -0,0 +1,7 @@
+parameters:
+	level: 9
+	paths:
+		- src
+	ignoreErrors:
+		- '#^Function config not found.$#'
+		- '#^Function config_path not found.$#'

phpunit.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/10.3/phpunit.xsd" bootstrap="vendor/autoload.php" executionOrder="depends,defects" beStrictAboutOutputDuringTests="true" failOnRisky="true" failOnWarning="true" cacheDirectory=".phpunit.cache" requireCoverageMetadata="true" beStrictAboutCoverageMetadata="true">
+  <testsuites>
+    <testsuite name="default">
+      <directory>tests</directory>
+    </testsuite>
+  </testsuites>
+  <coverage/>
+  <source>
+    <include>
+      <directory suffix=".php">src</directory>
+    </include>
+  </source>
+</phpunit>

src/ContentEncoding.php

@@ -0,0 +1,94 @@
+<?php
+
+namespace GreenTurtle\Middleware;
+
+use Closure;
+use GreenTurtle\Middleware\Encoder\ContentEncoder;
+use GreenTurtle\Middleware\Exception\FailedToEncode;
+use Illuminate\Http\Request;
+use Symfony\Component\HttpFoundation\Response;
+
+class ContentEncoding
+{
+    /** @var string[]  */
+    private readonly array $types;
+    /** @var ContentEncoder[]  */
+    private readonly array $encoders;
+
+    /**
+     * @param string[] $allowedTypes
+     * @param ContentEncoder[] $encoders
+     */
+    public function __construct(
+        private readonly bool $encodeUnknownType,
+        array $allowedTypes,
+        array $encoders
+    ) {
+        (fn(string ...$p) => true)(...$allowedTypes);
+        (fn(ContentEncoder ...$p) => true)(...$encoders);
+
+        $this->types = $allowedTypes;
+        $this->encoders = $encoders;
+    }
+
+    public function handle(Request $request, Closure $next): Response
+    {
+        $response = $next($request);
+        assert($response instanceof Response);
+
+        if (
+            !$response->getContent()
+            || $response->headers->has('Content-Encoding')
+            || !is_string($request->header('Accept-Encoding'))
+            || !$this->isEncodable($request->header('Content-Type'))
+        ) {
+            return $response;
+        }
+
+        [$encoding, $encoder] = $this->findEncoder($request->header('Accept-Encoding'));
+        if (is_null($encoding) || is_null($encoder)) {
+            return $response;
+        }
+
+        try {
+            $encodedContent = $encoder->encode($response->getContent());
+        } catch (FailedToEncode) {
+            return $response;
+        }
+
+        $response->headers->set('Content-Encoding', $encoding);
+        $response->setContent($encodedContent);
+        return $response;
+    }
+
+    private function isEncodable(mixed $contentType): bool
+    {
+        if (!is_string($contentType)) {
+            return $this->encodeUnknownType;
+        }
+
+        foreach ($this->types as $type) {
+            if (preg_match($type, $contentType) === 1) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /** @return array{?string, ?ContentEncoder}  */
+    private function findEncoder(string $acceptEncoding): array
+    {
+        $acceptEncodings = explode(',', str_replace(' ', '', $acceptEncoding));
+
+        foreach ($this->encoders as $encoder) {
+            foreach ($acceptEncodings as $acceptEncoding) {
+                if ($encoder->supports($acceptEncoding)) {
+                    return [$acceptEncoding, $encoder];
+                }
+            }
+        }
+
+        return [null, null];
+    }
+}

src/Encoder/ContentEncoder.php

@@ -0,0 +1,12 @@
+<?php
+
+declare(strict_types=1);
+
+namespace GreenTurtle\Middleware\Encoder;
+
+interface ContentEncoder
+{
+    public function supports(string $encoding): bool;
+
+    public function encode(string $content): string;
+}

src/Encoder/Deflate.php

@@ -0,0 +1,30 @@
+<?php
+
+declare(strict_types=1);
+
+namespace GreenTurtle\Middleware\Encoder;
+
+use GreenTurtle\Middleware\Exception\FailedToEncode;
+
+final class Deflate implements ContentEncoder
+{
+    private const SUPPORTED_ENCODINGS = [
+        'deflate',
+    ];
+
+    public function supports(string $encoding): bool
+    {
+        return in_array(strtolower($encoding), self::SUPPORTED_ENCODINGS);
+    }
+
+    public function encode(string $content): string
+    {
+        $encodedContent = gzdeflate($content);
+
+        if (!$encodedContent) {
+            throw FailedToEncode::errorOccured();
+        }
+
+        return $encodedContent;
+    }
+}

src/Encoder/Gzip.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace GreenTurtle\Middleware\Encoder;
+
+use GreenTurtle\Middleware\Exception\FailedToEncode;
+
+final class Gzip implements ContentEncoder
+{
+    private const SUPPORTED_ENCODINGS = [
+        'gzip',
+        'x-gzip',
+    ];
+
+    public function supports(string $encoding): bool
+    {
+        return in_array(strtolower($encoding), self::SUPPORTED_ENCODINGS);
+    }
+
+    public function encode(string $content): string
+    {
+        $encodedContent = gzencode($content);
+
+        if (!$encodedContent) {
+            throw FailedToEncode::errorOccured();
+        }
+
+        return $encodedContent;
+    }
+}