[13.x] Adds first-party support for image processing

composer.json

@@ -71,6 +71,7 @@
         "aws/aws-sdk-php": "^3.322.9",
         "fakerphp/faker": "^1.24",
         "guzzlehttp/psr7": "^2.4",
+        "intervention/image": "^3.11.7",
         "laravel/pint": "^1.18",
         "league/flysystem-aws-s3-v3": "^3.25.1",
         "league/flysystem-ftp": "^3.25.1",
@@ -143,6 +144,7 @@
         "ext-fileinfo": "Required to use the Filesystem class.",
         "ext-ftp": "Required to use the Flysystem FTP driver.",
         "ext-gd": "Required to use Illuminate\\Http\\Testing\\FileFactory::image().",
+        "intervention/image": "Required to use the image processing features (^3.11.7).",
         "ext-memcached": "Required to use the memcache cache driver.",
         "ext-pcntl": "Required to use all features of the queue worker and console signal trapping.",
         "ext-pdo": "Required to use all database features.",

config/image.php

@@ -0,0 +1,41 @@
+<?php
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Default Image Driver
+    |--------------------------------------------------------------------------
+    |
+    | This option controls the default image processing driver that will be
+    | used when manipulating or converting images. This driver is always
+    | utilized unless another driver is explicitly specified instead.
+    |
+    | Supported: "gd", "imagick", "cloudflare"
+    |
+    */
+
+    'default' => env('IMAGE_DRIVER', 'gd'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Image Drivers
+    |--------------------------------------------------------------------------
+    |
+    | Here you may configure the Cloudflare Images API credentials for the
+    | "cloudflare" image driver. The prefix option is used to namespace
+    | temporary uploads so that orphaned images may be pruned safely.
+    |
+    */
+
+    'drivers' => [
+
+        'cloudflare' => [
+            'account_id' => env('IMAGE_CLOUDFLARE_ACCOUNT_ID'),
+            'api_token' => env('IMAGE_CLOUDFLARE_API_TOKEN'),
+            'prefix' => env('IMAGE_CLOUDFLARE_PREFIX', 'laravel-image'),
+        ],
+
+    ],
+
+];

src/Illuminate/Contracts/Image/Driver.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Illuminate\Contracts\Image;
+
+use Illuminate\Foundation\Image\PendingImageOptions;
+
+interface Driver
+{
+    /**
+     * Process the given image contents with the specified options.
+     */
+    public function process(string $contents, PendingImageOptions $options): string;
+}

src/Illuminate/Filesystem/FilesystemAdapter.php

@@ -7,6 +7,7 @@
 use Illuminate\Contracts\Debug\ExceptionHandler;
 use Illuminate\Contracts\Filesystem\Cloud as CloudFilesystemContract;
 use Illuminate\Contracts\Filesystem\Filesystem as FilesystemContract;
+use Illuminate\Foundation\Image\Image;
 use Illuminate\Http\File;
 use Illuminate\Http\Request;
 use Illuminate\Http\UploadedFile;
@@ -284,6 +285,14 @@ public function path($path)
         return $this->prefixer->prefixPath($path);
     }
 
+    /**
+     * Create an image instance from a file in storage.
+     */
+    public function image(string $path): Image
+    {
+        return new Image(fn () => $this->get($path));
+    }
+
     /**
      * Get the contents of a file.
      *

src/Illuminate/Foundation/Application.php

@@ -1657,6 +1657,7 @@ public function registerCoreContainerAliases()
             'filesystem.disk' => [\Illuminate\Contracts\Filesystem\Filesystem::class],
             'filesystem.cloud' => [\Illuminate\Contracts\Filesystem\Cloud::class],
             'hash' => [\Illuminate\Hashing\HashManager::class],
+            'image' => [\Illuminate\Foundation\Image\ImageManager::class],
             'hash.driver' => [\Illuminate\Contracts\Hashing\Hasher::class],
             'log' => [\Illuminate\Log\LogManager::class, \Psr\Log\LoggerInterface::class],
             'mail.manager' => [\Illuminate\Mail\MailManager::class, \Illuminate\Contracts\Mail\Factory::class],

src/Illuminate/Foundation/Image/Drivers/CloudflareDriver.php

@@ -0,0 +1,233 @@
+<?php
+
+namespace Illuminate\Foundation\Image\Drivers;
+
+use DateTimeImmutable;
+use finfo;
+use Illuminate\Contracts\Image\Driver;
+use Illuminate\Foundation\Image\ImageException;
+use Illuminate\Foundation\Image\PendingImageOptions;
+use Illuminate\Http\Client\Factory as HttpFactory;
+use Illuminate\Http\Client\Pool;
+use Illuminate\Support\Str;
+
+class CloudflareDriver implements Driver
+{
+    /**
+     * Create a new Cloudflare driver instance.
+     */
+    public function __construct(
+        protected HttpFactory $http,
+        protected string $accountId,
+        protected string $apiToken,
+        protected string $prefix,
+    ) {
+        //
+    }
+
+    /**
+     * Ensure the Cloudflare credentials are configured.
+     *
+     * @throws ImageException
+     */
+    public function ensureRequirementsAreMet(): void
+    {
+        if (empty($this->accountId) || empty($this->apiToken)) {
+            throw new ImageException(
+                'The Cloudflare image driver requires an account ID and API token.',
+            );
+        }
+
+        if (empty($this->prefix)) {
+            throw new ImageException(
+                'The Cloudflare image driver requires a prefix for temporary uploads.',
+            );
+        }
+    }
+
+    /**
+     * Process the given image contents with the specified options.
+     *
+     * @throws ImageException
+     */
+    public function process(string $contents, PendingImageOptions $options): string
+    {
+        $sourceMimeType = (new finfo(FILEINFO_MIME_TYPE))->buffer($contents);
+
+        if (! in_array($sourceMimeType, ['image/jpeg', 'image/png', 'image/gif', 'image/webp'])) {
+            throw new ImageException("The image format [{$sourceMimeType}] is not supported by the Cloudflare driver.");
+        }
+
+        $id = $this->prefix.'/'.Str::random(40).match ($sourceMimeType) {
+            'image/jpeg' => '.jpg',
+            'image/png' => '.png',
+            'image/gif' => '.gif',
+            'image/webp' => '.webp',
+        };
+
+        $response = $this->http
+            ->withToken($this->apiToken)
+            ->attach('file', $contents, basename($id))
+            ->post("https://api.cloudflare.com/client/v4/accounts/{$this->accountId}/images/v1", [
+                'id' => $id,
+            ]);
+
+        if ($response->failed()) {
+            throw new ImageException(
+                'Cloudflare image upload failed: '.$response->json('errors.0.message', 'Unknown error'),
+                previous: $response->toException(),
+            );
+        }
+
+        return $this->transformAndDelete(
+            $response->json('result.id'),
+            $response->json('result.variants', []),
+            $options,
+            $contents,
+            $sourceMimeType,
+        );
+    }
+
+    /**
+     * Fetch the transformed image and delete the original from Cloudflare.
+     *
+     * @param  array<int, string>  $variants
+     */
+    protected function transformAndDelete(string $imageId, array $variants, PendingImageOptions $options, string $contents, string $sourceMimeType): string
+    {
+        try {
+            if (empty($variants)) {
+                throw new ImageException('Cloudflare did not return any image variants.');
+            }
+
+            $acceptMimeType = $options->format !== null
+                ? match ($options->format) {
+                    'webp' => 'image/webp',
+                    'jpg', 'jpeg' => 'image/jpeg',
+                }
+            : $sourceMimeType;
+
+            $request = $this->http->withHeaders([
+                'Accept' => $acceptMimeType,
+            ]);
+
+            $response = $request->get(
+                $this->buildTransformUrl($variants[0], $options, $contents),
+            );
+
+            if ($response->failed()) {
+                throw new ImageException(
+                    'Failed to fetch transformed image from Cloudflare: '.$response->json('errors.0.message', 'Unknown error'),
+                    previous: $response->toException(),
+                );
+            }
+
+            return $response->body();
+        } finally {
+            rescue(fn () => $this->deleteImage($imageId));
+        }
+    }
+
+    /**
+     * Build the Cloudflare transform URL with the given options.
+     */
+    protected function buildTransformUrl(string $baseUrl, PendingImageOptions $options, string $contents): string
+    {
+        $params = [];
+
+        if ($options->coverWidth !== null && $options->coverHeight !== null) {
+            $params[] = "width={$options->coverWidth}";
+            $params[] = "height={$options->coverHeight}";
+            $params[] = 'fit=cover';
+        } elseif ($options->scaleWidth !== null && $options->scaleHeight !== null) {
+            $params[] = "width={$options->scaleWidth}";
+            $params[] = "height={$options->scaleHeight}";
+            $params[] = 'fit=scale-down';
+        } else {
+            [$width, $height] = getimagesizefromstring($contents);
+
+            $params[] = "width={$width}";
+            $params[] = "height={$height}";
+            $params[] = 'fit=scale-down';
+        }
+
+        if ($options->blur !== null) {
+            $params[] = "blur={$options->blur}";
+        }
+
+        if ($options->greyscale) {
+            $params[] = 'saturation=0';
+        }
+
+        if ($options->sharpen !== null) {
+            $params[] = 'sharpen='.max(0, min(10, round($options->sharpen / 10)));
+        }
+
+        if ($options->flip && $options->flop) {
+            $params[] = 'flip=hv';
+        } elseif ($options->flip) {
+            $params[] = 'flip=v';
+        } elseif ($options->flop) {
+            $params[] = 'flip=h';
+        }
+
+        if ($options->format !== null) {
+            $params[] = 'format='.match ($options->format) {
+                'jpg' => 'jpeg',
+                default => $options->format,
+            };
+        }
+
+        $params[] = 'quality='.($options->quality ?? PendingImageOptions::DEFAULT_QUALITY);
+
+        return preg_replace('#/[^/]+$#', '/'.implode(',', $params), $baseUrl);
+    }
+
+    /**
+     * Delete orphaned images from Cloudflare that match the configured prefix.
+     */
+    public function pruneOrphaned(): void
+    {
+        $page = 1;
+
+        do {
+            $response = $this->http
+                ->withToken($this->apiToken)
+                ->get("https://api.cloudflare.com/client/v4/accounts/{$this->accountId}/images/v1", [
+                    'per_page' => 100,
+                    'page' => $page,
+                ]);
+
+            if ($response->failed()) {
+                throw new ImageException(
+                    'Failed to list images from Cloudflare: '.$response->json('errors.0.message', 'Unknown error'),
+                    previous: $response->toException(),
+                );
+            }
+
+            $images = $response->json('result.images', []);
+
+            collect($images)
+                ->filter(fn (array $image) => str_starts_with($image['id'], $this->prefix.'/'))
+                ->reject(fn (array $image) => (new DateTimeImmutable($image['uploaded']))->getTimestamp() > time() - 300)
+                ->pluck('id')
+                ->chunk(10)
+                ->each(fn ($chunk) => $this->http->pool(fn (Pool $pool) => $chunk->map(
+                    fn (string $id) => $pool->withToken($this->apiToken)
+                        ->delete("https://api.cloudflare.com/client/v4/accounts/{$this->accountId}/images/v1/{$id}"),
+                )->all()));
+
+            $page++;
+        } while (count($images) === 100);
+    }
+
+    /**
+     * Delete the temporary image from Cloudflare.
+     */
+    protected function deleteImage(string $imageId): void
+    {
+        $this->http
+            ->withToken($this->apiToken)
+            ->delete("https://api.cloudflare.com/client/v4/accounts/{$this->accountId}/images/v1/{$imageId}");
+    }
+}

src/Illuminate/Foundation/Image/Drivers/GdDriver.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Illuminate\Foundation\Image\Drivers;
+
+use Intervention\Image\ImageManager;
+
+class GdDriver extends InterventionDriver
+{
+    /**
+     * Create the underlying Intervention image manager.
+     */
+    protected function createManager(): ImageManager
+    {
+        return ImageManager::gd();
+    }
+}

src/Illuminate/Foundation/Image/Drivers/ImagickDriver.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Illuminate\Foundation\Image\Drivers;
+
+use Intervention\Image\ImageManager;
+
+class ImagickDriver extends InterventionDriver
+{
+    /**
+     * Create the underlying Intervention image manager.
+     */
+    protected function createManager(): ImageManager
+    {
+        return ImageManager::imagick();
+    }
+}