b2b-platform-utils 1.1.56 → 1.1.58

package/errorsMap.js

@@ -880,6 +880,54 @@ const STATIC_ERRORS = [
     httpCode: 503,
     description: "Service is temporarily unavailable.",
   },
+  {
+    errorCode: 1144,
+    errorKey: "promocodeInvalid",
+    httpCode: 422,
+    description: "Promo code is invalid or cannot be applied.",
+  },
+  {
+    errorCode: 1145,
+    errorKey: "promocodeExpired",
+    httpCode: 422,
+    description: "Promo code is expired.",
+  },
+  {
+    errorCode: 1146,
+    errorKey: "promocodeUsageLimitReached",
+    httpCode: 422,
+    description: "Promo code usage limit has been reached.",
+  },
+  {
+    errorCode: 1147,
+    errorKey: "promocodeApplicationModeMismatch",
+    httpCode: 422,
+    description: "Promo code application mode does not match the requested operation.",
+  },
+  {
+    errorCode: 1148,
+    errorKey: "promocodeTargetBonusAlreadyOwned",
+    httpCode: 422,
+    description: "Target bonus is already owned by the user.",
+  },
+  {
+    errorCode: 1149,
+    errorKey: "promocodeTargetBonusUnavailable",
+    httpCode: 422,
+    description: "Target bonus is not available for this promo code.",
+  },
+  {
+    errorCode: 1150,
+    errorKey: "promocodeAlreadyApplied",
+    httpCode: 422,
+    description: "Promo code has already been applied.",
+  },
+  {
+    errorCode: 1151,
+    errorKey: "promocodeNotActive",
+    httpCode: 422,
+    description: "Promo code is not active.",
+  },
 ];
 
 const STATIC_BY_KEY = Object.fromEntries(

package/optimizeMedia.js

@@ -82,8 +82,185 @@ async function saveGameImageBufferWEBPWithOptions(fileDataBuffer, options = {})
         .toBuffer();
 }
 
+const WEBP_CONVERSION_FORMATS = new Set(['jpeg', 'png', 'webp']);
+
+function normalizeImageFileType(originalFileType) {
+    if (!originalFileType) {
+        return null;
+    }
+
+    let type = String(originalFileType).toLowerCase().replace(/^\./, '');
+
+    if (type === 'jpg') {
+        type = 'jpeg';
+    }
+
+    return type;
+}
+
+function isKnownFormat(fileType) {
+    return fileType === 'gif' || fileType === 'avif' || WEBP_CONVERSION_FORMATS.has(fileType);
+}
+
+function hasResizeOptions(options) {
+    const { maxWidth, width, height } = options;
+
+    return width != null || height != null || maxWidth != null;
+}
+
+function buildResizeOptions(options) {
+    const {
+        maxWidth,
+        width,
+        height,
+        fit = 'inside',
+        withoutEnlargement = true
+    } = options;
+
+    const resizeOptions = { fit, withoutEnlargement };
+
+    if (width != null) {
+        resizeOptions.width = width;
+    } else if (maxWidth != null) {
+        resizeOptions.width = maxWidth;
+    }
+
+    if (height != null) {
+        resizeOptions.height = height;
+    }
+
+    return resizeOptions;
+}
+
+async function resizePipelineIfNeeded(pipeline, fileDataBuffer, options) {
+    const { resize = 1 } = options;
+
+    if (hasResizeOptions(options)) {
+        return pipeline.resize(buildResizeOptions(options));
+    }
+
+    if (resize !== 1) {
+        const metadata = await sharp(fileDataBuffer).metadata();
+        const newWidth = Math.round(metadata.width * resize);
+        const newHeight = Math.round(metadata.height * resize);
+
+        return pipeline.resize(newWidth, newHeight);
+    }
+
+    return pipeline;
+}
+
+async function encodeWebpBuffer(fileDataBuffer, options) {
+    let pipeline = sharp(fileDataBuffer);
+    pipeline = await resizePipelineIfNeeded(pipeline, fileDataBuffer, options);
+
+    return pipeline
+        .webp({
+            quality: options.quality,
+            lossless: false,
+            smartSubsample: options.smartSubsample,
+            effort: options.effort,
+            alphaQuality: options.alphaQuality
+        })
+        .toBuffer();
+}
+
+/**
+ * Format-aware image optimization: preserves GIF/AVIF, converts JPEG/PNG/WebP to WebP, safe fallback on failure.
+ * @param {Buffer} fileDataBuffer
+ * @param {string} originalFileType
+ * @param {object} [options]
+ * @returns {Promise<{ buffer: Buffer, fileType: string, optimized: boolean }>}
+ */
+async function optimizeImageBufferByFormat(fileDataBuffer, originalFileType, options = {}) {
+    const opts = {
+        quality: 80,
+        resize: 1,
+        alphaQuality: 80,
+        maxWidth: null,
+        width: null,
+        height: null,
+        fit: 'inside',
+        withoutEnlargement: true,
+        effort: 5,
+        smartSubsample: true,
+        ...options
+    };
+
+    let normalizedType = normalizeImageFileType(originalFileType);
+
+    try {
+        if (normalizedType === 'gif') {
+            return { buffer: fileDataBuffer, fileType: 'gif', optimized: false };
+        }
+
+        if (!normalizedType || !isKnownFormat(normalizedType)) {
+            const metadata = await sharp(fileDataBuffer).metadata();
+            const metadataType = normalizeImageFileType(metadata.format);
+
+            if (metadataType) {
+                normalizedType = metadataType;
+            }
+        }
+
+        if (normalizedType === 'gif') {
+            return { buffer: fileDataBuffer, fileType: 'gif', optimized: false };
+        }
+
+        if (normalizedType === 'avif') {
+            try {
+                let pipeline = sharp(fileDataBuffer);
+
+                if (hasResizeOptions(opts)) {
+                    pipeline = pipeline.resize(buildResizeOptions(opts));
+                }
+
+                const buffer = await pipeline
+                    .avif({
+                        quality: opts.quality,
+                        effort: opts.effort
+                    })
+                    .toBuffer();
+
+                return { buffer, fileType: 'avif', optimized: true };
+            } catch {
+                return { buffer: fileDataBuffer, fileType: 'avif', optimized: false };
+            }
+        }
+
+        if (WEBP_CONVERSION_FORMATS.has(normalizedType)) {
+            try {
+                const buffer = await encodeWebpBuffer(fileDataBuffer, opts);
+
+                return { buffer, fileType: 'webp', optimized: true };
+            } catch {
+                return { buffer: fileDataBuffer, fileType: normalizedType, optimized: false };
+            }
+        }
+
+        try {
+            const buffer = await encodeWebpBuffer(fileDataBuffer, opts);
+
+            return { buffer, fileType: 'webp', optimized: true };
+        } catch {
+            return {
+                buffer: fileDataBuffer,
+                fileType: normalizedType || 'bin',
+                optimized: false
+            };
+        }
+    } catch {
+        return {
+            buffer: fileDataBuffer,
+            fileType: normalizedType || normalizeImageFileType(originalFileType) || 'bin',
+            optimized: false
+        };
+    }
+}
+
 module.exports = {
     optimizeImageBufferWEBP,
     saveGameImageBufferWEBP,
-    saveGameImageBufferWEBPWithOptions
+    saveGameImageBufferWEBPWithOptions,
+    optimizeImageBufferByFormat
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "b2b-platform-utils",
-  "version": "1.1.56",
+  "version": "1.1.58",
   "description": "Shared utilities for Node.js microservices: errors map, local cache, logger, numbers, dates, filesystem, media optimization, paginator, slugger, crypto wrapper, sanitize HTML, sorting.",
   "type": "commonjs",
   "license": "KingSizer",