IBX-11383: Hash image file in a deterministic way during storing to avoid pilling up duplicates

src/lib/FieldType/Image/ImageStorage.php

@@ -96,7 +96,11 @@ public function storeFieldData(VersionInfo $versionInfo, Field $field, array $co
                 ),
                 $field->value->externalData['fileName']
             );
-            $targetPath = $this->filePathNormalizer->normalizePath($targetPath);
+            $targetPath = $this->filePathNormalizer->normalizePath(
+                $targetPath,
+                true,
+                $field->value->externalData['inputUri'] ?? null,
+            );
 
             if (isset($field->value->externalData['inputUri'])) {
                 $localFilePath = $field->value->externalData['inputUri'];

src/lib/IO/FilePathNormalizer/Flysystem.php

@@ -8,6 +8,7 @@
 
 namespace Ibexa\Core\IO\FilePathNormalizer;
 
+use const DIRECTORY_SEPARATOR;
 use Ibexa\Core\IO\FilePathNormalizerInterface;
 use Ibexa\Core\Persistence\Legacy\Content\UrlAlias\SlugConverter;
 use League\Flysystem\PathNormalizer;
@@ -26,22 +27,29 @@ public function __construct(SlugConverter $slugConverter, PathNormalizer $pathNo
         $this->pathNormalizer = $pathNormalizer;
     }
 
-    public function normalizePath(string $filePath, bool $doHash = true): string
+    public function normalizePath(string $filePath, bool $doHash = true, ?string $realFilePath = null): string
     {
         $fileName = pathinfo($filePath, PATHINFO_BASENAME);
         $directory = pathinfo($filePath, PATHINFO_DIRNAME);
 
         $fileName = $this->slugConverter->convert($fileName, '_1', 'urlalias');
 
-        $hash = $doHash
-            ? (preg_match(self::HASH_PATTERN, $fileName) ? '' : bin2hex(random_bytes(6)) . '-')
+        $hash = $doHash && !preg_match(self::HASH_PATTERN, $fileName)
+            ? $this->generateFilePathHash($realFilePath)
             : '';
 
-        $filePath = $directory . \DIRECTORY_SEPARATOR . $hash;
+        $filePath = $directory . DIRECTORY_SEPARATOR . $hash;
         $normalizedFileName = $this->pathNormalizer->normalizePath($fileName);
 
         return $filePath . $normalizedFileName;
     }
+
+    private function generateFilePathHash(?string $realFilePath = null): string
+    {
+        $hash = $realFilePath !== null ? md5_file($realFilePath) : false;
+
+        return ($hash !== false ? substr($hash, 0, 12) : bin2hex(random_bytes(6))) . '-';
+    }
 }
 
 class_alias(Flysystem::class, 'eZ\Publish\Core\IO\FilePathNormalizer\Flysystem');

src/lib/IO/FilePathNormalizerInterface.php

@@ -13,7 +13,7 @@
  */
 interface FilePathNormalizerInterface
 {
-    public function normalizePath(string $filePath, bool $doHash = true): string;
+    public function normalizePath(string $filePath, bool $doHash = true, ?string $realFilePath = null): string;
 }
 
 class_alias(FilePathNormalizerInterface::class, 'eZ\Publish\Core\IO\FilePathNormalizerInterface');

tests/integration/Core/Image/ImageStorage/ImageStorageTest.php

@@ -173,6 +173,71 @@ public function testStoreFieldDataDuringUpdateWithDifferentImage(VersionInfo $ve
         self::assertSame(1, $this->gateway->countImageReferences($binaryFile->uri));
     }
 
+    /**
+     * @dataProvider providerOfFieldData
+     */
+    public function testStoreFieldDataWithSameImageOnAutosave(VersionInfo $versionInfo, Field $field): void
+    {
+        $targetPath = '1/8/6/232-eng-GB/' . $field->value->externalData['fileName'];
+
+        $binaryFile = new BinaryFile([
+            'id' => $targetPath,
+            'uri' => $targetPath,
+        ]);
+
+        $this->filePathNormalizer
+            ->expects(self::exactly(2))
+            ->method('normalizePath')
+            ->willReturn($targetPath);
+
+        $this->ioService
+            ->expects(self::exactly(2))
+            ->method('newBinaryCreateStructFromLocalFile')
+            ->with($field->value->externalData['inputUri'])
+            ->willReturn(new BinaryFileCreateStruct());
+
+        $this->ioService
+            ->expects(self::exactly(2))
+            ->method('createBinaryFile')
+            ->willReturn($binaryFile);
+
+        $this->ioService
+            ->expects(self::exactly(2))
+            ->method('getMimeType')
+            ->with($binaryFile->id)
+            ->willReturn('image/jpeg');
+
+        $this->redecorator
+            ->method('redecorateFromSource')
+            ->with($binaryFile->uri)
+            ->willReturn($binaryFile->uri);
+
+        // First save
+        $this->storage->storeFieldData($versionInfo, $field, $this->getContext());
+
+        // Simulate autosave with same image — rebuild externalData
+        $field->value = new FieldValue([
+            'externalData' => [
+                'id' => null,
+                'path' => $field->value->data['path'] ?? __DIR__ . '/image.jpg',
+                'inputUri' => __DIR__ . '/image.jpg',
+                'fileName' => 'image.jpg',
+                'fileSize' => '12345',
+                'mimeType' => 'image/jpeg',
+                'width' => null,
+                'height' => null,
+                'alternativeText' => null,
+                'imageId' => null,
+                'uri' => null,
+                'additionalData' => [],
+            ],
+        ]);
+
+        $this->storage->storeFieldData($versionInfo, $field, $this->getContext());
+
+        self::assertSame(1, $this->gateway->countImageReferences($binaryFile->uri));
+    }
+
     private function runCommonStoreFieldDataMocks(Field $field): BinaryFile
     {
         $this->filePathNormalizer

tests/lib/IO/FilePathNormalizer/FlysystemTest.php

@@ -112,4 +112,53 @@ public function providerForTestNormalizePath(): array
             ],
         ];
     }
+
+    public function testNormalizePathWithRealFilePath(): void
+    {
+        $tempFile = tempnam(sys_get_temp_dir(), 'test_image_');
+        file_put_contents($tempFile, 'test image content');
+
+        try {
+            $md5File = md5_file($tempFile);
+            self::assertNotFalse($md5File);
+            $expectedHash = substr($md5File, 0, 12);
+
+            $this->slugConverter
+                ->expects(self::once())
+                ->method('convert')
+                ->with('image.jpg')
+                ->willReturn('image.jpg');
+
+            $normalizedPath = $this->filePathNormalizer->normalizePath(
+                '4/3/2/234/1/image.jpg',
+                true,
+                $tempFile,
+            );
+
+            self::assertSame('4/3/2/234/1/' . $expectedHash . '-image.jpg', $normalizedPath);
+        } finally {
+            unlink($tempFile);
+        }
+    }
+
+    public function testNormalizePathWithRealFilePathIsDeterministic(): void
+    {
+        $tempFile = tempnam(sys_get_temp_dir(), 'test_image_');
+        file_put_contents($tempFile, 'test image content');
+
+        try {
+            $this->slugConverter
+                ->expects(self::exactly(2))
+                ->method('convert')
+                ->with('image.jpg')
+                ->willReturn('image.jpg');
+
+            $first = $this->filePathNormalizer->normalizePath('4/3/2/234/1/image.jpg', true, $tempFile);
+            $second = $this->filePathNormalizer->normalizePath('4/3/2/234/1/image.jpg', true, $tempFile);
+
+            self::assertSame($first, $second);
+        } finally {
+            unlink($tempFile);
+        }
+    }
 }