Update image-processing-logic.js

image-processing-logic.js

@@ -1,12 +1,24 @@
 const sharp = require('sharp');
 const stream = require('stream');
 
+/**
+ * PRODUCTION OPTIMIZATION:
+ * Force sharp to use 1 thread per image operation.
+ * This is the recommended setting for web servers handling many concurrent requests.
+ * It prevents thread starvation and memory fragmentation by letting Node's libuv
+ * thread pool (UV_THREADPOOL_SIZE) handle concurrency at the request level instead.
+ */
+sharp.concurrency(1);
+
 class ImageProcessor {
     /**
      * Processes an image to CMYK TIFF format from a readable stream.
+     * Accepts PNG, JPEG, WebP, AVIF, and TIFF inputs.
+     * Outputs the highest-quality CMYK TIFF suitable for professional printing.
+     * 
      * @param {stream.Readable} input - The incoming stream of image data.
-     * @param {Object } options - Processing options including quality.
-     * @returns {stream.Readable} - A readable stream of the processed CMYK TIFF image.
+     * @param {Object} options - Processing options including quality.
+     * @returns {Promise<stream.Readable>} - A readable stream of the processed CMYK TIFF image.
      */
     processImage(input, options = {}) {
         return new Promise((resolve, reject) => {
@@ -24,15 +36,28 @@ class ImageProcessor {
                 sharpInstance.on('error', (error) => {
                     reject(new Error(`Image processing failed: ${error.message}`));
                 });
-const compressionLevel = Math.max(1, Math.min(9, Math.round(parseInt(quality) / 100 * 9)));
-                // Apply CMYK conversion with TIFF compression
+
+                const compressionLevel = Math.max(1, Math.min(9, Math.round(parseInt(quality) / 100 * 9)));
+
+                /**
+                 * CMYK conversion pipeline:
+                 * - toColorspace('cmyk'): Converts from any input colorspace to CMYK.
+                 * - compression: 'deflate' provides lossless PNG-style compression.
+                 * - quality: 100 ensures no lossy degradation.
+                 * - predictor: 'horizontal' improves deflate compression ratios on photographic data.
+                 * 
+                 * NOTE: The input can be WebP (lossy or lossless). Sharp's libvips will decode
+                 * WebP to full uncompressed pixel data before conversion, so there is ZERO quality
+                 * loss from the transport format — the TIFF output quality depends only on the
+                 * original render resolution (600 DPI), not the transport encoding.
+                 */
                 sharpInstance = sharpInstance
                     .toColorspace('cmyk')
                     .tiff({ 
-                        compression: 'deflate', // CHANGED: Use PNG-style lossless compression
-            quality: 100, // This is now ignored, but we set to 100
-            level: compressionLevel, // NEW: Use our mapped level
-            predictor: 'horizontal'
+                        compression: 'deflate',
+                        quality: 100,
+                        level: compressionLevel,
+                        predictor: 'horizontal'
                     });
 
                 // Create transform stream for error handling
@@ -70,7 +95,6 @@ const compressionLevel = Math.max(1, Math.min(9, Math.round(parseInt(quality) /
     validateOptions(options) {
         const { quality } = options;
         
-        // Validate quality exists and is valid
         if (quality && isNaN(quality)) {
             throw new Error('Quality must be a number');
         }
@@ -85,7 +109,8 @@ const compressionLevel = Math.max(1, Math.min(9, Math.round(parseInt(quality) /
     }
 
     /**
-     * Validates the input content type
+     * Validates the input content type.
+     * Now accepts image/webp for optimized frontend transfers.
      * @param {string} contentType - Request content type
      */
     validateContentType(contentType) {