b2b-platform-utils 0.1.0 → 1.1.1

package/cryptoWrapper.js

@@ -1,7 +1,6 @@
 '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');
@@ -12,31 +11,30 @@ let keyLen = 64;
 
 module.exports = {
     /**
-     * Get salt value from in-memory cache or fallback to config file.
+     * Get salt value from in-memory cache or fallback to config file ./config/config.json (resolved from process.cwd()).
      */
     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;
+            try {
+                let config = readFile('./config/config.json'); // resolved relative to service root
+                config = JSON.parse(config);
+                salt = config?.salt;
+            } catch {
+                // Intentionally swallow ENOENT/parse errors; caller will fail deterministically if salt is missing.
+            }
         }
         return salt;
     },
 
-    /**
-     * Derive a password hash using PBKDF2-SHA512.
-     */
+    /** 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.
-     */
+    /** Constant-time style comparison for provided password vs stored hash. */
     validatePassword: (password, hash) => {
         const derived = crypto
             .pbkdf2Sync(password, module.exports.getSalt(), iterationsCount, keyLen, 'sha512')

package/errorsMap.js

@@ -1,25 +1,112 @@
 '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)).
+// Purpose: Static error map with backward compatibility and dynamic shortcuts.
+// - Old style calls like errorsMap.mailTemplateNotFound?.() continue to work.
+// - Any property access matching an errorKey returns a function that yields JSON.stringify(error).
+// - New API: get(), getString(), getCode(), list(), and legacy getSingleError().
+// - Cache-first: if localCache.errorsMap exists, it overrides static entries.
 
 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);
+// ---- Static fallback (source of truth when cache is empty) ----
+const STATIC_ERRORS = [
+    { errorCode: 1000, errorKey: 'userNotFound',              httpCode: 404, description: 'User was not found' },
+    { errorCode: 1001, errorKey: 'unauthorized',              httpCode: 401, description: 'The server requires user authentication' },
+    { errorCode: 1002, errorKey: 'gameCategoryNotFound',      httpCode: 404, description: 'Game`s category was not found' },
+    { errorCode: 1003, errorKey: 'mediaResourceNotFound',     httpCode: 404, description: 'Media resource was not found' },
+    { errorCode: 1004, errorKey: 'roleNotFound',              httpCode: 404, description: 'Role or permission were not found' },
+    { errorCode: 1005, errorKey: 'duplicatedUniqueField',     httpCode: 422, description: 'Some of unique fields were duplicated.' },
+    { errorCode: 1006, errorKey: 'gameCollectionNotFound',    httpCode: 404, description: 'Game`s collection was not found' },
+    { errorCode: 1007, errorKey: 'gameTagNotFound',           httpCode: 404, description: 'Game`s tag was not found' },
+    { errorCode: 1008, errorKey: 'invalidConstraintField',    httpCode: 422, description: 'Some of foreign keys fields were invalid.' },
+    { errorCode: 1009, errorKey: 'gameProviderNotFound',      httpCode: 404, description: 'Game`s provider was not found' },
+    { errorCode: 1010, errorKey: 'gameNotFound',              httpCode: 404, description: 'Game was not found' },
+    { errorCode: 1011, errorKey: 'undefinedRequest',          httpCode: 422, description: 'Request data or format is undefined for handler.' },
+    { errorCode: 1012, errorKey: 'widgetNotFound',            httpCode: 404, description: 'Widget[CMS] was not found' },
+    { errorCode: 1013, errorKey: 'segmentNotFound',           httpCode: 404, description: 'User`s Segment was not found' },
+    { errorCode: 1014, errorKey: 'bonusNotFound',             httpCode: 404, description: 'Bonus was not found' },
+    { errorCode: 1015, errorKey: 'userBonusNotFound',         httpCode: 404, description: 'User`s bonus was not found' },
+    { errorCode: 1016, errorKey: 'freeSpinsNotFound',         httpCode: 404, description: 'Free spins was not found' },
+    { errorCode: 1017, errorKey: 'gameWagerListNotFound',     httpCode: 404, description: 'Game`s wager list was not found' },
+    { errorCode: 1018, errorKey: 'bonusAlreadyInUse',         httpCode: 422, description: 'Bonus is already use(d)' },
+    { errorCode: 1019, errorKey: 'bonusRestrictForClaim',     httpCode: 422, description: 'Bonus does not fit for user`s claiming' },
+    { errorCode: 1020, errorKey: 'bonusRewardAttachError',    httpCode: 422, description: 'Bonus reward can not be attached.' },
+    { errorCode: 1021, errorKey: 'loyaltyLevelNotFound',      httpCode: 404, description: 'Loyalty level was not found' },
+    { errorCode: 1022, errorKey: 'loyaltyPointNotFound',      httpCode: 404, description: 'Loyalty point was not found' },
+    { errorCode: 1023, errorKey: 'notificationNotFound',      httpCode: 404, description: 'Notification was not found' },
+    { errorCode: 1024, errorKey: 'bannerNotFound',            httpCode: 404, description: 'Banner was not found' },
+    { errorCode: 1025, errorKey: 'paymentProviderNotFound',   httpCode: 404, description: 'Payment provider was not found' },
+    { errorCode: 1026, errorKey: 'paymentMethodNotFound',     httpCode: 404, description: 'Payment method was not found' },
+    { errorCode: 1027, errorKey: 'depositNotFound',           httpCode: 404, description: 'Deposit was not found' },
+    { errorCode: 1028, errorKey: 'withdrawalNotFound',        httpCode: 404, description: 'Withdrawal was not found' },
+    { errorCode: 1029, errorKey: 'noteNotFound',              httpCode: 404, description: 'User`s Note was not found' },
+    { errorCode: 1030, errorKey: 'promoCodeNotFound',         httpCode: 404, description: 'Promo Code was not found' },
+    { errorCode: 1031, errorKey: 'cashBackNotFound',          httpCode: 404, description: 'Cash Back was not found' },
+    { errorCode: 1032, errorKey: 'tournamentNotFound',        httpCode: 404, description: 'Tournament was not found' },
+    { errorCode: 1033, errorKey: 'pageNotFound',              httpCode: 404, description: 'Page was not found' },
+    { errorCode: 1034, errorKey: 'gameCashBackListNotFound',  httpCode: 404, description: 'Game`s cash back list was not found' },
+    { errorCode: 1035, errorKey: 'bonusDepositRequired',      httpCode: 404, description: 'For bonus activation desposit requited.' },
+    { errorCode: 1036, errorKey: 'taskNotFound',              httpCode: 404, description: 'Task for schedule was not found.' },
+    { errorCode: 1037, errorKey: 'bonusConfirmationRequired', httpCode: 404, description: 'For bonus activation confirmation of personal user data requited.' },
+    { errorCode: 1038, errorKey: 'promoNotFound',             httpCode: 404, description: 'Promo was not found.' },
+    { errorCode: 1039, errorKey: 'badSignature',              httpCode: 401, description: 'Untrusted request, bad signature.' },
+    { errorCode: 1040, errorKey: 'mailTemplateNotFound',      httpCode: 404, description: 'Email template was not found.' }
+];
+
+const STATIC_BY_KEY = Object.fromEntries(STATIC_ERRORS.map(e => [e.errorKey, e]));
+
+/** Resolve error by key from cache (if any) or static table. */
+function resolveErrorByKey(errorKey) {
+    const cached = getValue('errorsMap');
+    if (Array.isArray(cached) && cached.length) {
+        const hit = cached.find((item) => item?.errorKey === errorKey);
+        if (hit) return hit;
     }
+    return STATIC_BY_KEY[errorKey];
+}
+
+// --- Base API object (do not export directly; we wrap it in a Proxy) ---
+const api = {
+    /** Legacy accessor kept for compatibility. */
+    getSingleError: (errorKey) => {
+        const obj = resolveErrorByKey(errorKey);
+        return obj ? JSON.stringify(obj) : undefined;
+    },
+
+    /** New API: get full error object. */
+    get: (errorKey) => resolveErrorByKey(errorKey),
+
+    /** New API: get JSON version (same as legacy). */
+    getString: (errorKey) => {
+        const obj = resolveErrorByKey(errorKey);
+        return obj ? JSON.stringify(obj) : undefined;
+    },
+
+    /** New API: get numeric error code. */
+    getCode: (errorKey) => resolveErrorByKey(errorKey)?.errorCode,
+
+    /** New API: list all static errors (useful for diagnostics). */
+    list: () => [...STATIC_ERRORS]
 };
+
+// --- Dynamic shortcuts: errorsMap.<errorKey>() returns JSON string ---
+// This keeps old style calls working across all services without hand-written wrappers.
+module.exports = new Proxy(api, {
+    get(target, prop, receiver) {
+        // If method exists (get, getString, etc.) → return it
+        if (prop in target) return Reflect.get(target, prop, receiver);
+
+        // If property is a known errorKey → return a function () => getString(errorKey)
+        if (typeof prop === 'string' && STATIC_BY_KEY[prop]) {
+            return () => target.getString(prop);
+        }
+
+        // Otherwise, undefined (so optional chaining ?.() is safe)
+        return undefined;
+    },
+
+    // Optional: make `prop in errorsMap` truthy for known keys
+    has(target, prop) {
+        return prop in target || (typeof prop === 'string' && !!STATIC_BY_KEY[prop]);
+    }
+});

package/fileSystem.js

@@ -1,28 +1,40 @@
 'use strict';
 
-// Purpose: Simple sync file helpers for small config/state blobs.
+// Purpose: Simple sync file helpers that resolve relative paths from the service root (process.cwd()).
 
 const fs = require('fs');
+const path = require('path');
+
+/** Resolve absolute path; if relative, resolve from process.cwd(). */
+function resolvePath(fileName) {
+    return path.isAbsolute(fileName) ? fileName : path.resolve(process.cwd(), fileName);
+}
 
 module.exports = {
     /**
      * Save data as JSON into a file (overwrites if exists).
+     * Ensures parent directory exists.
      */
     saveFile: (fileName, data) => {
-        fs.writeFileSync(fileName, JSON.stringify(data));
+        const p = resolvePath(fileName);
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.writeFileSync(p, JSON.stringify(data));
     },
 
     /**
      * Read text content from a file using UTF-8.
+     * Relative paths are resolved from process.cwd().
      */
     readFile: (fileName) => {
-        return fs.readFileSync(fileName, 'utf-8');
+        const p = resolvePath(fileName);
+        return fs.readFileSync(p, 'utf-8');
     },
 
     /**
      * Remove a file from the filesystem.
      */
     removeFile: (fileName) => {
-        fs.unlinkSync(fileName);
+        const p = resolvePath(fileName);
+        fs.unlinkSync(p);
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "b2b-platform-utils",
-  "version": "0.1.0",
+  "version": "1.1.1",
   "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",
@@ -22,4 +22,4 @@
     "moment": "^2.30.1",
     "sharp": "^0.33.0"
   }
-}
+}