feat(server): JXL previews from DNG 1.7+ (#17861)

* feat(server): JXL previews from RAW

* refactor(server): use var name assumedExtractedFormat for clarity

* test(server): fix existing media.extract() returning JPEG

* chore(openapi): regen

* style(server): lint

* fix(server): ignore undefined decode orientation

* fix(server): correct orientation assignment in media decode options

* test(server): unit tests of JXL-encoded DNG

* refactor(server): return buffer and format from mediaRepository.extract()

* chore(open-api): regen

* refactor

---------

Co-authored-by: mertalev <101130780+mertalev@users.noreply.github.com>

server/src/repositories/media.repository.ts

@@ -7,7 +7,7 @@ import { Writable } from 'node:stream';
 import sharp from 'sharp';
 import { ORIENTATION_TO_SHARP_ROTATION } from 'src/constants';
 import { Exif } from 'src/database';
-import { Colorspace, LogLevel } from 'src/enum';
+import { Colorspace, LogLevel, RawExtractedFormat } from 'src/enum';
 import { LoggingRepository } from 'src/repositories/logging.repository';
 import {
   DecodeToBufferOptions,
@@ -36,34 +36,51 @@ type ProgressEvent = {
   percent?: number;
 };
 
+export type ExtractResult = {
+  buffer: Buffer;
+  format: RawExtractedFormat;
+};
+
 @Injectable()
 export class MediaRepository {
   constructor(private logger: LoggingRepository) {
     this.logger.setContext(MediaRepository.name);
   }
 
-  async extract(input: string, output: string): Promise<boolean> {
+  /**
+   *
+   * @param input file path to the input image
+   * @returns ExtractResult if succeeded, or null if failed
+   */
+  async extract(input: string): Promise<ExtractResult | null> {
     try {
-      // remove existing output file if it exists
-      // as exiftool-vendored does not support overwriting via "-w!" flag
-      // and throws "1 files could not be read" error when the output file exists
-      await fs.unlink(output).catch(() => null);
-      await exiftool.extractBinaryTag('JpgFromRaw2', input, output);
-    } catch {
-      try {
-        this.logger.debug('Extracting JPEG from RAW image:', input);
-        await exiftool.extractJpgFromRaw(input, output);
-      } catch (error: any) {
-        this.logger.debug('Could not extract JPEG from image, trying preview', error.message);
-        try {
-          await exiftool.extractPreview(input, output);
-        } catch (error: any) {
-          this.logger.debug('Could not extract preview from image', error.message);
-          return false;
-        }
-      }
+      const buffer = await exiftool.extractBinaryTagToBuffer('JpgFromRaw2', input);
+      return { buffer, format: RawExtractedFormat.JPEG };
+    } catch (error: any) {
+      this.logger.debug('Could not extract JpgFromRaw2 buffer from image, trying JPEG from RAW next', error.message);
+    }
+
+    try {
+      const buffer = await exiftool.extractBinaryTagToBuffer('JpgFromRaw', input);
+      return { buffer, format: RawExtractedFormat.JPEG };
+    } catch (error: any) {
+      this.logger.debug('Could not extract JPEG buffer from image, trying PreviewJXL next', error.message);
+    }
+
+    try {
+      const buffer = await exiftool.extractBinaryTagToBuffer('PreviewJXL', input);
+      return { buffer, format: RawExtractedFormat.JXL };
+    } catch (error: any) {
+      this.logger.debug('Could not extract PreviewJXL buffer from image, trying PreviewImage next', error.message);
+    }
+
+    try {
+      const buffer = await exiftool.extractBinaryTagToBuffer('PreviewImage', input);
+      return { buffer, format: RawExtractedFormat.JPEG };
+    } catch (error: any) {
+      this.logger.debug('Could not extract preview buffer from image', error.message);
+      return null;
     }
-    return true;
   }
 
   async writeExif(tags: Partial<Exif>, output: string): Promise<boolean> {
@@ -104,7 +121,7 @@ export class MediaRepository {
     }
   }
 
-  decodeImage(input: string, options: DecodeToBufferOptions) {
+  decodeImage(input: string | Buffer, options: DecodeToBufferOptions) {
     return this.getImageDecodingPipeline(input, options).raw().toBuffer({ resolveWithObject: true });
   }
 
@@ -235,7 +252,7 @@ export class MediaRepository {
     });
   }
 
-  async getImageDimensions(input: string): Promise<ImageDimensions> {
+  async getImageDimensions(input: string | Buffer): Promise<ImageDimensions> {
     const { width = 0, height = 0 } = await sharp(input).metadata();
     return { width, height };
   }