b2b-platform-utils 0.1.0

package/README.md

@@ -0,0 +1,15 @@
+# platform-utils
+
+Shared utilities for Node.js microservices (CommonJS).  
+This package centralizes small, repeated helpers used across services so they can be maintained in one place.
+
+> Node.js ≥ 18 is required. License: **KingSizer**.  
+> Intended for **private** use (published to npmjs.org as a restricted package).
+
+---
+
+## Install
+
+```bash
+# make sure your .npmrc has a valid auth token for npmjs.org
+npm i platform-utils

package/cryptoWrapper.js

@@ -0,0 +1,46 @@
+'use strict';
+
+// Purpose: PBKDF2-based password hashing/validation with a salt fetched from cache or config file.
+// Note: Public API preserved exactly.
+
+const crypto = require('crypto');
+const { getValue } = require('./localCache');
+const { readFile } = require('./fileSystem');
+
+let iterationsCount = 200;
+let keyLen = 64;
+
+module.exports = {
+    /**
+     * Get salt value from in-memory cache or fallback to config file.
+     */
+    getSalt: () => {
+        let salt = getValue('salt');
+        // Migrations/seeders flow when keys are not existing in runtime
+        if (!salt) {
+            let config = readFile('./config/config.json');
+            config = JSON.parse(config);
+            salt = config?.salt;
+        }
+        return salt;
+    },
+
+    /**
+     * Derive a password hash using PBKDF2-SHA512.
+     */
+    generatePassword: (password) => {
+        return crypto
+            .pbkdf2Sync(password, module.exports.getSalt(), iterationsCount, keyLen, 'sha512')
+            .toString('hex');
+    },
+
+    /**
+     * Constant-time style comparison for provided password vs stored hash.
+     */
+    validatePassword: (password, hash) => {
+        const derived = crypto
+            .pbkdf2Sync(password, module.exports.getSalt(), iterationsCount, keyLen, 'sha512')
+            .toString('hex');
+        return hash === derived;
+    }
+};

package/dates.js

@@ -0,0 +1,47 @@
+'use strict';
+
+// Purpose: Date formatting and normalization utilities using moment.
+// Note: Combines both your variants and preserves existing exports/signatures.
+
+const moment = require('moment');
+
+/**
+ * Returns a date/time format string by logical format key.
+ * Preserves all aliases and additional cases you listed.
+ */
+function getDateFormat(format) {
+    switch (format) {
+        case 'birthday':
+        case 'short':
+            return 'DD.MM.YYYY';
+        case 'regular':
+        case 'bonus':
+        case 'registration':
+        case 'tournament':
+        case 'promo':
+            return 'DD.MM.YYYY HH:mm';
+        default:
+            return 'DD.MM.YYYY HH:mm:ss';
+    }
+}
+
+module.exports = {
+    getDateFormat,
+
+    /**
+     * Parse a birthday value with "birthday" date format and return a UTC moment.
+     * Original behavior preserved.
+     */
+    getBirthdayDate: (value) => {
+        return moment(value, getDateFormat('birthday')).utc(true);
+    },
+
+    /**
+     * Convert any Date-like input to a UTC moment; returns null if invalid.
+     * Original behavior preserved.
+     */
+    getDateInUtc: (date) => {
+        const converted = new Date(date);
+        return (moment.isDate(converted)) ? moment.utc(converted) : null;
+    }
+};

package/errorsMap.js

@@ -0,0 +1,25 @@
+'use strict';
+
+// Purpose: Provide a consistent way to look up predefined error objects from in-memory cache.
+// Note: Keeps the original public API and behavior (returns JSON.stringify(currentError)).
+
+const { getValue } = require('./localCache');
+
+module.exports = {
+    duplicatedUniqueField: () => module.exports.getSingleError('duplicatedUniqueField'),
+    invalidConstraintField: () => module.exports.getSingleError('invalidConstraintField'),
+    mediaResourceNotFound: () => module.exports.getSingleError('mediaResourceNotFound'),
+    notificationNotFound: () => module.exports.getSingleError('notificationNotFound'),
+    mailTemplateNotFound: () => module.exports.getSingleError('mailTemplateNotFound'),
+    undefinedRequest: () => module.exports.getSingleError('undefinedRequest'),
+
+    /**
+     * Returns a stringified error object by key from the cached "errorsMap" array.
+     * Keeps original behavior: JSON.stringify(undefined) => undefined.
+     */
+    getSingleError: (errorKey) => {
+        const errors = getValue('errorsMap');
+        const currentError = errors?.find((item) => item.errorKey === errorKey);
+        return JSON.stringify(currentError);
+    }
+};

package/fileSystem.js

@@ -0,0 +1,28 @@
+'use strict';
+
+// Purpose: Simple sync file helpers for small config/state blobs.
+
+const fs = require('fs');
+
+module.exports = {
+    /**
+     * Save data as JSON into a file (overwrites if exists).
+     */
+    saveFile: (fileName, data) => {
+        fs.writeFileSync(fileName, JSON.stringify(data));
+    },
+
+    /**
+     * Read text content from a file using UTF-8.
+     */
+    readFile: (fileName) => {
+        return fs.readFileSync(fileName, 'utf-8');
+    },
+
+    /**
+     * Remove a file from the filesystem.
+     */
+    removeFile: (fileName) => {
+        fs.unlinkSync(fileName);
+    }
+};

package/localCache.js

@@ -0,0 +1,87 @@
+'use strict';
+
+// Purpose: Lightweight in-memory key-value store scoped to the running process.
+// Note: Added setService(key) to allow passing microservice key without breaking existing API.
+
+let cacheData = {};
+let serviceKey = 'notification';
+let bufferChunkSize = 512000;
+const GEO_DEFAULT = 'WW';
+
+function setValue(key, value) {
+    cacheData[key] = value;
+}
+
+function getValue(key) {
+    return cacheData[key] || null;
+}
+
+function getCommonValue() {
+    return cacheData['common'] || {};
+}
+
+/**
+ * Return current microservice key.
+ */
+function getService() {
+    return serviceKey;
+}
+
+/**
+ * Allow overriding the microservice key at runtime (non-breaking addition).
+ */
+function setService(key) {
+    if (typeof key === 'string' && key.length) {
+        serviceKey = key;
+    }
+}
+
+function getBufferChunkSize() {
+    return bufferChunkSize;
+}
+
+/**
+ * Initialize environment/customer from process params (kept as-is).
+ */
+function parseInitConfig(params) {
+    const environment = params[2];
+    const customer = params[3];
+    setValue('environment', environment);
+    setValue('customer', customer);
+}
+
+/**
+ * Shallow-apply a config object into the cache.
+ */
+function applyConfig(data) {
+    for (const i in data) {
+        setValue(i, data[i]);
+    }
+}
+
+/**
+ * Return the whole cache snapshot (by reference).
+ */
+function getData() {
+    return cacheData;
+}
+
+/**
+ * Read GEODefault from "common" bag or return fallback.
+ */
+function getDefaultGEO() {
+    return getValue('common')?.GEODefault || GEO_DEFAULT;
+}
+
+module.exports = {
+    setValue,
+    getValue,
+    parseInitConfig,
+    applyConfig,
+    getData,
+    getService,
+    setService,
+    getBufferChunkSize,
+    getDefaultGEO,
+    getCommonValue
+};

package/logger.js

@@ -0,0 +1,33 @@
+'use strict';
+
+// Purpose: Colorized console logging helpers for quick CLI visibility.
+
+module.exports = {
+    /**
+     * Print a debug payload as magenta JSON.
+     */
+    debug: (data) => {
+        console.log(`\x1b[35m❗ ${JSON.stringify(data)} [DEBUG] \x1b[0m`);
+    },
+
+    /**
+     * Print a green success note.
+     */
+    successNote: (message) => {
+        console.info(`\x1b[32m✅ ${message?.toString()} \x1b[0m`);
+    },
+
+    /**
+     * Print a red critical note.
+     */
+    criticalNote: (message) => {
+        console.info(`\x1b[31m⛔ ${message?.toString()} ⛔\x1b[0m`);
+    },
+
+    /**
+     * Print a yellow warning note.
+     */
+    warningNote: (message) => {
+        console.warn(`\x1b[33m❗ ${message?.toString()} ❗\x1b[0m`);
+    }
+};

package/numbers.js

@@ -0,0 +1,10 @@
+'use strict';
+
+// Purpose: Numeric validators and helpers.
+
+/**
+ * Validate that a provided value is a finite, non-negative number.
+ */
+const isValidPositiveNumber = (v) => v != null && !isNaN(v) && v >= 0;
+
+module.exports = { isValidPositiveNumber };

package/optimizeMedia.js

@@ -0,0 +1,48 @@
+'use strict';
+
+// Purpose: Image optimization helpers powered by Sharp.
+
+const sharp = require('sharp');
+
+/**
+ * Convert a buffer to resized WebP with adjustable quality and alpha quality.
+ * Preserves original function name and signature.
+ */
+async function optimizeImageBufferWEBP(fileDataBuffer, quality = 80, resize = 1, alphaQuality = 80) {
+    const metadata = await sharp(fileDataBuffer).metadata();
+    const newWidth = Math.round(metadata.width * resize);
+    const newHeight = Math.round(metadata.height * resize);
+
+    return sharp(fileDataBuffer)
+        .resize(newWidth, newHeight)
+        .webp({
+            quality,
+            lossless: false,       // true — without losses (larger size), false — with losses
+            smartSubsample: true,  // better quality on small details
+            effort: 6,             // 0 (fast) — 6 (slower, better compression)
+            alphaQuality
+        })
+        .toBuffer();
+}
+
+/**
+ * Resize a buffer to a max width and convert to WebP for game images.
+ * Preserves original function name and signature.
+ */
+async function saveGameImageBufferWEBP(fileDataBuffer, quality = 80, maxWidth = 300) {
+    return sharp(fileDataBuffer)
+        .rotate()
+        .resize({
+            width: maxWidth,
+            fit: 'inside',
+            withoutEnlargement: true
+        })
+        .webp({
+            quality,
+            effort: 5,
+            smartSubsample: true
+        })
+        .toBuffer();
+}
+
+module.exports = { optimizeImageBufferWEBP, saveGameImageBufferWEBP };

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "b2b-platform-utils",
+  "version": "0.1.0",
+  "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",
+  "private": false,
+  "files": [
+    "*.js",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "nodejs",
+    "utils",
+    "microservices",
+    "commonjs"
+  ],
+  "dependencies": {
+    "moment": "^2.30.1",
+    "sharp": "^0.33.0"
+  }
+}

package/paginator.js

@@ -0,0 +1,11 @@
+'use strict';
+
+// Purpose: Compute total pages given a total count and page size.
+// Note: Keeps the exact public API and semantics.
+
+module.exports = {
+    getTotalPages: (totalItems, limit = 0) => {
+        const totalPages = (totalItems && (+limit > 0)) ? +(totalItems / limit) : 0;
+        return (totalPages <= 1) ? 1 : +Math.ceil(totalPages);
+    }
+};

package/sanitizeHtml.js

@@ -0,0 +1,67 @@
+'use strict';
+
+// Purpose: Remove inline data:image payloads and related attributes from HTML safely.
+// Note: Converted to CommonJS while keeping the same function name and behavior.
+
+function stripInlineImages(html) {
+    // Removing <img ... src="data:image/...">
+    html = html.replace(
+        /<img\b[^>]*\bsrc\s*=\s*(['"])\s*data\s*:\s*image\/[^"']+\1[^>]*>/gi,
+        ''
+    );
+    html = html.replace(
+        /<img\b[^>]*\bsrc\s*=\s*data\s*:\s*image\/[^\s>]+[^>]*>/gi,
+        ''
+    );
+
+    // Removing srcset with data:image
+    html = html.replace(/\bsrcset\s*=\s*(['"])[\s\S]*?\1/gi, (m) => {
+        const q = m.match(/^(srcset\s*=\s*)(['"])([\s\S]*)(\2)$/i);
+        if (!q) return m;
+        const list = q[3]
+            .split(',')
+            .map((s) => s.trim())
+            .filter((item) => !/^\s*data\s*:\s*image\//i.test(item));
+        return list.length ? `srcset="${list.join(', ')}"` : '';
+    });
+
+    // Removing <source> with data:image in src/srcset
+    html = html.replace(
+        /<source\b[^>]*\b(?:src|srcset)\s*=\s*(['"])\s*data\s*:\s*image\/[^"']+\1[^>]*>/gi,
+        ''
+    );
+
+    // Posters/background with data:image
+    html = html.replace(/\bposter\s*=\s*(['"])\s*data\s*:\s*image\/[^"']+\1/gi, 'poster=""');
+    html = html.replace(/\bbackground\s*=\s*(['"])\s*data\s*:\s*image\/[^"']+\1/gi, '');
+
+    // <link rel="icon" href="data:image/...">
+    html = html.replace(
+        /<link\b[^>]*\brel\s*=\s*(['"])\s*icon\1[^>]*\bhref\s*=\s*(['"])\s*data\s*:\s*image\/[^"']+\2[^>]*>/gi,
+        ''
+    );
+
+    // Clear inline CSS url(data:...)
+    html = html.replace(/url\(\s*(['"])?\s*data\s*:\s*image\/[^"')]+(\1)?\s*\)/gi, 'none');
+
+    // Inside <style>...</style>
+    html = html.replace(
+        /(<style\b[^>]*>)([\s\S]*?)(<\/style>)/gi,
+        (_, open, css, close) =>
+            open + css.replace(/url\(\s*(['"])?\s*data\s*:\s*image\/[^"')]+(\1)?\s*\)/gi, 'none') + close
+    );
+
+    // Fix accidental Cyrillic <п> tags to <p>
+    html = html.replace(/<\/\s*п\s*>/g, '</p>').replace(/<\s*п(\s|>)/g, '<p$1>');
+
+    // Remove empty <h2><br/></h2> and <p><br/></p>
+    html = html.replace(/<h2[^>]*>\s*<br\s*\/?>\s*<\/h2>/gi, '<h2></h2>');
+    html = html.replace(/<p[^>]*>\s*<br\s*\/?>\s*<\/p>/gi, '<p></p>');
+
+    // Normalize redundant spaces before tags
+    html = html.replace(/\s+(?=<)/g, ' ');
+
+    return html;
+}
+
+module.exports = { stripInlineImages };

package/slugger.js

@@ -0,0 +1,59 @@
+'use strict';
+
+// Purpose: Normalize a string into a URL-friendly slug.
+
+module.exports = {
+    /**
+     * Convert input string to a normalized slug using replacements you provided.
+     * Preserves exact behavior and replacements.
+     */
+    setSlug: (inputSlug = null) => {
+        if (!inputSlug) { return ''; }
+        return inputSlug.toString().toLowerCase()
+            .replaceAll(' ', '-')
+            .replaceAll('’', '')
+            .replaceAll('‘', '')
+            .replaceAll("'", '')
+            .replaceAll(':', '')
+            .replaceAll(';', '')
+            .replaceAll('_', '-')
+            .replaceAll(',', '')
+            .replaceAll('.', '')
+            .replaceAll('"', '')
+            // Specials
+            .replaceAll('!', '')
+            .replaceAll('@', '')
+            .replaceAll('#', '')
+            .replaceAll('$', '')
+            .replaceAll('%', '')
+            .replaceAll('^', '')
+            .replaceAll('*', '')
+            .replaceAll('(', '')
+            .replaceAll(')', '')
+            .replaceAll('=', '')
+            .replaceAll('|', '')
+            .replaceAll('&', 'and')
+            // Umlautes
+            .replaceAll('ö', 'o')
+            .replaceAll('ô', 'o')
+            .replaceAll('ü', 'u')
+            .replaceAll('û', 'u')
+            .replaceAll('ù', 'u')
+            .replaceAll('ü', 'u')
+            .replaceAll('ä', 'a')
+            .replaceAll('æ', 'a')
+            .replaceAll('ø', 'a')
+            .replaceAll('å', 'a')
+            .replaceAll('à', 'a')
+            .replaceAll('â', 'a')
+            .replaceAll('ß', 's')
+            .replaceAll('é', 'e')
+            .replaceAll('è', 'e')
+            .replaceAll('ë', 'e')
+            .replaceAll('î', 'i')
+            .replaceAll('ï', 'i')
+            .replaceAll('Ç', 'c')
+            // Brands
+            .replaceAll('™', 'TM');
+    }
+};

package/sorting.js

@@ -0,0 +1,31 @@
+'use strict';
+
+// Purpose: Helpers to build stable sorting arrays and validate directions.
+
+const validDirections = ['ASC', 'DESC'];
+
+/**
+ * Convert an object like { field: 'ASC', other: 'DESC' } into [['field','ASC'], ['other','DESC']]
+ * Invalid directions are filtered out.
+ */
+function getSortedArray(sortingObject) {
+    return Object.entries(sortingObject)
+        .map(([key, value]) => {
+            const field = key;
+            const direction = String(value).toUpperCase();
+            if (validDirections.includes(direction)) {
+                return [field, direction];
+            }
+            return null;
+        })
+        .filter(Boolean);
+}
+
+/**
+ * Check if a direction value is valid (ASC|DESC), case-insensitive.
+ */
+function isValidDirection(directionFromField) {
+    return validDirections.includes(directionFromField?.toUpperCase());
+}
+
+module.exports = { getSortedArray, isValidDirection };