b2b-platform-utils 1.1.64 → 1.1.68

package/errorsMap.js

@@ -941,6 +941,60 @@ const STATIC_ERRORS = [
     httpCode: 503,
     description: "Provider request is temporarily throttled, try again later.",
   },
+  {
+    errorCode: 1154,
+    errorKey: "twoFaAlreadyEnabled",
+    httpCode: 422,
+    description: "Two factor authentication is already enabled.",
+  },
+  {
+    errorCode: 1155,
+    errorKey: "twoFaNotEnabled",
+    httpCode: 422,
+    description: "Two factor authentication is not enabled.",
+  },
+  {
+    errorCode: 1156,
+    errorKey: "twoFaSetupRequired",
+    httpCode: 422,
+    description: "Two factor authentication setup is required.",
+  },
+  {
+    errorCode: 1157,
+    errorKey: "twoFaChallengeNotFound",
+    httpCode: 404,
+    description: "Two factor authentication challenge was not found.",
+  },
+  {
+    errorCode: 1158,
+    errorKey: "twoFaChallengeExpired",
+    httpCode: 422,
+    description: "Two factor authentication challenge is expired.",
+  },
+  {
+    errorCode: 1159,
+    errorKey: "twoFaTooManyAttempts",
+    httpCode: 429,
+    description: "Too many two factor authentication attempts.",
+  },
+  {
+    errorCode: 1160,
+    errorKey: "twoFaInvalidPurpose",
+    httpCode: 422,
+    description: "Two factor authentication purpose is missing or invalid.",
+  },
+  {
+    errorCode: 1161,
+    errorKey: "twoFaPendingSecretMissing",
+    httpCode: 422,
+    description: "Two factor authentication pending secret is missing.",
+  },
+  {
+    errorCode: 1162,
+    errorKey: "twoFaSecretMissing",
+    httpCode: 422,
+    description: "Two factor authentication secret is missing.",
+  },
 ];
 
 const STATIC_BY_KEY = Object.fromEntries(

package/fileSystem.js

@@ -311,6 +311,42 @@ function getAbsoluteMediaResourceUrl(service, instance, fileName) {
   return `${baseUrl}/file/${service}/${instance}/${fileName}`;
 }
 
+/**
+ * Normalize an HTTP Content-Type header value.
+ *
+ * @param {string|undefined|null} contentType
+ * @returns {string}
+ */
+function normalizeContentType(contentType) {
+  if (contentType == null || contentType === "") {
+    return "";
+  }
+
+  const normalized = String(contentType).trim().toLowerCase();
+  const semicolonIndex = normalized.indexOf(";");
+  return semicolonIndex >= 0
+    ? normalized.slice(0, semicolonIndex).trim()
+    : normalized;
+}
+
+/**
+ * Resolve download options with existing defaults.
+ *
+ * @param {Object} [options]
+ * @returns {{ timeoutMs: number, maxBytes: number, maxRedirects: number }}
+ */
+function resolveDownloadOptions(options = {}) {
+  return {
+    timeoutMs: Number.isInteger(options.timeoutMs) ? options.timeoutMs : 15000,
+    maxBytes: Number.isInteger(options.maxBytes)
+      ? options.maxBytes
+      : 25 * 1024 * 1024,
+    maxRedirects: Number.isInteger(options.maxRedirects)
+      ? options.maxRedirects
+      : 3,
+  };
+}
+
 /**
  * Download remote resource to Buffer or read local file to Buffer.
  *
@@ -322,50 +358,85 @@ function getAbsoluteMediaResourceUrl(service, instance, fileName) {
  * @returns {Promise<Buffer>}
  */
 function downloadToBuffer(source, options = {}) {
-  const timeoutMs = Number.isInteger(options.timeoutMs)
-    ? options.timeoutMs
-    : 15000;
-  const maxBytes = Number.isInteger(options.maxBytes)
-    ? options.maxBytes
-    : 25 * 1024 * 1024;
-  const maxRedirects = Number.isInteger(options.maxRedirects)
-    ? options.maxRedirects
-    : 3;
+  return downloadToBufferWithMetadata(source, options).then(
+    (result) => result.buffer
+  );
+}
+
+/**
+ * Download remote resource or read local file with response metadata.
+ *
+ * @param {string} source - URL (http/https) or local file path.
+ * @param {Object} [options]
+ * @param {number} [options.timeoutMs=15000] - Request timeout.
+ * @param {number} [options.maxBytes=26214400] - Max allowed size in bytes (default 25MB).
+ * @param {number} [options.maxRedirects=3] - Max redirects to follow.
+ * @returns {Promise<{ buffer: Buffer, contentType: string, finalUrl: string }>}
+ */
+async function downloadToBufferWithMetadata(source, options = {}) {
+  const { timeoutMs, maxBytes, maxRedirects } =
+    resolveDownloadOptions(options);
 
   if (!source || typeof source !== "string") {
-    return Promise.reject(
-      new TypeError("downloadToBuffer: source must be a non-empty string")
+    throw new TypeError(
+      "downloadToBuffer: source must be a non-empty string"
     );
   }
 
   const trimmed = source.trim();
 
   if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
-    return downloadHttpToBuffer(trimmed, { timeoutMs, maxBytes, maxRedirects });
+    return downloadHttpWithMetadata(trimmed, {
+      timeoutMs,
+      maxBytes,
+      maxRedirects,
+    });
   }
 
   const absPath = resolvePath(trimmed);
-  return fsPromises.readFile(absPath);
+  const buffer = await fsPromises.readFile(absPath);
+
+  return {
+    buffer,
+    contentType: getMimeTypeByFileExtension(absPath),
+    finalUrl: absPath,
+  };
 }
 
 /**
- * Download an HTTP/HTTPS resource to Buffer with basic redirect support.
+ * Download an HTTP/HTTPS resource with metadata and basic redirect support.
  *
  * @param {string} url
  * @param {Object} options
  * @param {number} options.timeoutMs
  * @param {number} options.maxBytes
  * @param {number} options.maxRedirects
- * @returns {Promise<Buffer>}
+ * @returns {Promise<{ buffer: Buffer, contentType: string, finalUrl: string }>}
  */
-function downloadHttpToBuffer(url, options) {
+function downloadHttpWithMetadata(url, options) {
   return new Promise((resolve, reject) => {
     const client = url.startsWith("https://") ? https : http;
+    let settled = false;
+    let resRef = null;
+
+    const finalize = (err, result) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+
+      if (err) {
+        reject(err instanceof Error ? err : new Error(String(err)));
+        return;
+      }
+
+      resolve(result);
+    };
 
     const req = client.get(url, (res) => {
+      resRef = res;
       const statusCode = res.statusCode || 0;
 
-      // Follow redirects
       if (
         statusCode >= 300 &&
         statusCode < 400 &&
@@ -374,17 +445,23 @@ function downloadHttpToBuffer(url, options) {
       ) {
         res.resume();
         const nextUrl = new URL(res.headers.location, url).toString();
-        return resolve(
-          downloadHttpToBuffer(nextUrl, {
-            ...options,
-            maxRedirects: options.maxRedirects - 1,
-          })
-        );
+        return downloadHttpWithMetadata(nextUrl, {
+          ...options,
+          maxRedirects: options.maxRedirects - 1,
+        })
+          .then((result) => finalize(null, result))
+          .catch((err) =>
+            finalize(
+              new Error(
+                err?.details || err?.message || err
+              )
+            )
+          );
       }
 
       if (statusCode < 200 || statusCode >= 300) {
         res.resume();
-        return reject(
+        return finalize(
           new Error(
             `downloadToBuffer: request failed with status ${statusCode}`
           )
@@ -394,10 +471,13 @@ function downloadHttpToBuffer(url, options) {
       const chunks = [];
       let received = 0;
 
-      res.on("data", (chunk) => {
+      const onData = (chunk) => {
         received += chunk.length;
         if (received > options.maxBytes) {
-          req.destroy(
+          res.removeListener("data", onData);
+          res.destroy();
+          req.destroy();
+          finalize(
             new Error(
               `downloadToBuffer: maxBytes exceeded (${options.maxBytes})`
             )
@@ -405,19 +485,38 @@ function downloadHttpToBuffer(url, options) {
           return;
         }
         chunks.push(chunk);
+      };
+
+      res.on("data", onData);
+
+      res.on("end", () => {
+        if (settled) {
+          return;
+        }
+
+        finalize(null, {
+          buffer: Buffer.concat(chunks),
+          contentType: normalizeContentType(res.headers["content-type"]),
+          finalUrl: url,
+        });
       });
 
-      res.on("end", () => resolve(Buffer.concat(chunks)));
-      res.on("error", reject);
+      res.on("error", (err) =>
+        finalize(new Error(err?.details || err?.message || err))
+      );
     });
 
     req.setTimeout(options.timeoutMs, () => {
-      req.destroy(
+      resRef?.destroy();
+      req.destroy();
+      finalize(
         new Error(`downloadToBuffer: timeout after ${options.timeoutMs}ms`)
       );
     });
 
-    req.on("error", reject);
+    req.on("error", (err) =>
+      finalize(new Error(err?.details || err?.message || err))
+    );
   });
 }
 
@@ -434,6 +533,7 @@ module.exports = {
   removeFile,
   unlinkIfExists,
   downloadToBuffer,
+  downloadToBufferWithMetadata,
 
   // MIME helpers
   getImageExtension,

package/optimizeMedia.js

@@ -83,13 +83,40 @@ async function saveGameImageBufferWEBPWithOptions(fileDataBuffer, options = {})
 }
 
 const WEBP_CONVERSION_FORMATS = new Set(['jpeg', 'png', 'webp']);
+const MANDATORY_PASSTHROUGH_FORMATS = new Set(['gif', 'avif', 'svg']);
+
+const MIME_TO_EXTENSION = {
+    'image/jpeg': 'jpeg',
+    'image/jpg': 'jpeg',
+    'image/png': 'png',
+    'image/webp': 'webp',
+    'image/gif': 'gif',
+    'image/avif': 'avif',
+    'image/svg+xml': 'svg'
+};
 
 function normalizeImageFileType(originalFileType) {
     if (!originalFileType) {
         return null;
     }
 
-    let type = String(originalFileType).toLowerCase().replace(/^\./, '');
+    let type = String(originalFileType).trim().toLowerCase();
+
+    if (!type) {
+        return null;
+    }
+
+    const semicolonIndex = type.indexOf(';');
+
+    if (semicolonIndex !== -1) {
+        type = type.slice(0, semicolonIndex).trim();
+    }
+
+    if (MIME_TO_EXTENSION[type]) {
+        return MIME_TO_EXTENSION[type];
+    }
+
+    type = type.replace(/^\./, '');
 
     if (type === 'jpg') {
         type = 'jpeg';
@@ -98,8 +125,27 @@ function normalizeImageFileType(originalFileType) {
     return type;
 }
 
+function buildPassthroughFormats(options) {
+    const passthroughSet = new Set(MANDATORY_PASSTHROUGH_FORMATS);
+    const configured = options.passthroughFormats;
+
+    if (!Array.isArray(configured)) {
+        return passthroughSet;
+    }
+
+    for (const value of configured) {
+        const normalized = normalizeImageFileType(value);
+
+        if (normalized) {
+            passthroughSet.add(normalized);
+        }
+    }
+
+    return passthroughSet;
+}
+
 function isKnownFormat(fileType) {
-    return fileType === 'gif' || fileType === 'avif' || WEBP_CONVERSION_FORMATS.has(fileType);
+    return MANDATORY_PASSTHROUGH_FORMATS.has(fileType) || WEBP_CONVERSION_FORMATS.has(fileType);
 }
 
 function hasResizeOptions(options) {
@@ -151,7 +197,7 @@ async function resizePipelineIfNeeded(pipeline, fileDataBuffer, options) {
 }
 
 async function encodeWebpBuffer(fileDataBuffer, options) {
-    let pipeline = sharp(fileDataBuffer);
+    let pipeline = sharp(fileDataBuffer).rotate();
     pipeline = await resizePipelineIfNeeded(pipeline, fileDataBuffer, options);
 
     return pipeline
@@ -166,7 +212,7 @@ async function encodeWebpBuffer(fileDataBuffer, options) {
 }
 
 /**
- * Format-aware image optimization: preserves GIF/AVIF, converts JPEG/PNG/WebP to WebP, safe fallback on failure.
+ * Format-aware image optimization: preserves GIF/AVIF/SVG, converts JPEG/PNG/WebP to WebP, safe fallback on failure.
  * @param {Buffer} fileDataBuffer
  * @param {string} originalFileType
  * @param {object} [options]
@@ -187,10 +233,11 @@ async function optimizeImageBufferByFormat(fileDataBuffer, originalFileType, opt
         ...options
     };
 
+    const passthroughFormats = buildPassthroughFormats(opts);
     let normalizedType = normalizeImageFileType(originalFileType);
 
     try {
-        if (normalizedType === 'gif' || normalizedType === 'avif') {
+        if (normalizedType && passthroughFormats.has(normalizedType)) {
             return { buffer: fileDataBuffer, fileType: normalizedType, optimized: false };
         }
 
@@ -203,7 +250,7 @@ async function optimizeImageBufferByFormat(fileDataBuffer, originalFileType, opt
             }
         }
 
-        if (normalizedType === 'gif' || normalizedType === 'avif') {
+        if (normalizedType && passthroughFormats.has(normalizedType)) {
             return { buffer: fileDataBuffer, fileType: normalizedType, optimized: false };
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "b2b-platform-utils",
-  "version": "1.1.64",
+  "version": "1.1.68",
   "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",