@seip/blue-bird 1.1.3 → 1.1.5

package/core/hash.js

@@ -1,201 +1,201 @@
-import crypto from "node:crypto";
-
-let bcryptModule = null;
-try {
-  bcryptModule = (await import("bcrypt")).default || (await import("bcrypt"));
-} catch {
-  // bcrypt not installed, scrypt native is used
-}
-
-/**
- * High-performance Password Hashing class.
- * Uses native node:crypto scrypt by default (zero npm dependencies, NIST recommended),
- * with seamless support for bcrypt when installed or verifying bcrypt hashes.
- */
-class Hash {
-  /**
-   * Hashes a plain text password using scrypt (default) or bcrypt.
-   * @param {string} password - The plain text password.
-   * @param {Object} [options={}] - Hashing options.
-   * @param {string} [options.driver="scrypt"] - Hashing driver ('scrypt' or 'bcrypt').
-   * @param {number} [options.rounds=10] - Salt rounds for bcrypt (if driver is 'bcrypt').
-   * @param {number} [options.N=16384] - CPU/memory cost parameter for scrypt.
-   * @param {number} [options.r=8] - Block size for scrypt.
-   * @param {number} [options.p=1] - Parallelization parameter for scrypt.
-   * @returns {Promise<string>} Formatted password hash string.
-   * @example
-   * const hash = await Hash.make("mySecretPassword");
-   * // Using bcrypt:
-   * const bcryptHash = await Hash.make("mySecretPassword", { driver: "bcrypt" });
-   */
-  static async make(password, options = {}) {
-    if (typeof password !== "string" || !password) {
-      throw new Error("[HASH ERROR] Password must be a non-empty string.");
-    }
-
-    const driver = (options.driver || "scrypt").toLowerCase();
-
-    if (driver === "bcrypt") {
-      if (!bcryptModule) {
-        throw new Error(
-          "[HASH ERROR] 'bcrypt' package is not installed. Run 'npm install bcrypt' or 'npx blue-bird add bcrypt', or use the default scrypt driver.",
-        );
-      }
-      const rounds = options.rounds || 10;
-      return bcryptModule.hash(password, rounds);
-    }
-
-    // Default: native scrypt with random salt
-    const N = options.N || 16384;
-    const r = options.r || 8;
-    const p = options.p || 1;
-    const keylen = 64;
-    const salt = crypto.randomBytes(16);
-
-    return new Promise((resolve, reject) => {
-      crypto.scrypt(
-        password,
-        salt,
-        keylen,
-        { N, r, p, maxmem: 32 * 1024 * 1024 },
-        (err, derivedKey) => {
-          if (err) return reject(err);
-          const hashString = `$scrypt$N=${N},r=${r},p=${p}$${salt.toString("hex")}$${derivedKey.toString("hex")}`;
-          resolve(hashString);
-        },
-      );
-    });
-  }
-
-  /**
-   * Alias for make().
-   * @param {string} password - The plain text password.
-   * @param {Object} [options={}] - Options.
-   * @returns {Promise<string>}
-   */
-  static async hash(password, options = {}) {
-    return this.make(password, options);
-  }
-
-  /**
-   * Verifies a plain text password against a hash string.
-   * Automatically detects scrypt or bcrypt hash formats.
-   * Uses timing-safe comparison to protect against side-channel attacks.
-   *
-   * @param {string} password - The plain text password to check.
-   * @param {string} hash - The stored hash string.
-   * @returns {Promise<boolean>} True if password matches, false otherwise.
-   * @example
-   * const isValid = await Hash.verify("mySecretPassword", storedHash);
-   */
-  static async verify(password, hash) {
-    if (
-      typeof password !== "string" ||
-      !password ||
-      typeof hash !== "string" ||
-      !hash
-    ) {
-      return false;
-    }
-
-    // 1. Detect bcrypt hash format ($2a$, $2b$, $2y$)
-    if (/^\$2[aby]\$\d{2}\$/.test(hash)) {
-      if (!bcryptModule) {
-        console.error(
-          "[HASH ERROR] A bcrypt hash was detected, but the 'bcrypt' package is not installed. Run 'npm install bcrypt' or 'npx blue-bird add bcrypt'.",
-        );
-        return false;
-      }
-      try {
-        return await bcryptModule.compare(password, hash);
-      } catch {
-        return false;
-      }
-    }
-
-    // 2. Detect native scrypt format ($scrypt$N=...,r=...,p=...$salt$hash)
-    if (hash.startsWith("$scrypt$")) {
-      const parts = hash.split("$");
-      // Format: ["", "scrypt", "N=16384,r=8,p=1", "saltHex", "hashHex"]
-      if (parts.length !== 5) return false;
-
-      const paramsStr = parts[2];
-      const saltHex = parts[3];
-      const originalHashHex = parts[4];
-
-      if (!paramsStr || !saltHex || !originalHashHex) return false;
-
-      let N = 16384,
-        r = 8,
-        p = 1;
-      paramsStr.split(",").forEach((param) => {
-        const [k, v] = param.split("=");
-        if (k === "N") N = parseInt(v, 10) || N;
-        if (k === "r") r = parseInt(v, 10) || r;
-        if (k === "p") p = parseInt(v, 10) || p;
-      });
-
-      const salt = Buffer.from(saltHex, "hex");
-      const originalHash = Buffer.from(originalHashHex, "hex");
-
-      return new Promise((resolve) => {
-        crypto.scrypt(
-          password,
-          salt,
-          originalHash.length,
-          { N, r, p, maxmem: 32 * 1024 * 1024 },
-          (err, derivedKey) => {
-            if (err) return resolve(false);
-            try {
-              const matches = crypto.timingSafeEqual(originalHash, derivedKey);
-              resolve(matches);
-            } catch {
-              resolve(false);
-            }
-          },
-        );
-      });
-    }
-
-    return false;
-  }
-
-  /**
-   * Alias for verify().
-   * @param {string} password - The plain text password.
-   * @param {string} hash - The stored hash string.
-   * @returns {Promise<boolean>}
-   */
-  static async check(password, hash) {
-    return this.verify(password, hash);
-  }
-
-  /**
-   * Checks if a given hash needs to be rehashed to match updated security parameters.
-   * @param {string} hash - The stored hash string.
-   * @param {Object} [options={}] - Target options.
-   * @returns {boolean} True if the hash should be regenerated.
-   */
-  static needsRehash(hash, options = {}) {
-    if (!hash || typeof hash !== "string") return true;
-    const targetDriver = (options.driver || "scrypt").toLowerCase();
-
-    if (targetDriver === "bcrypt") {
-      return !/^\$2[aby]\$\d{2}\$/.test(hash);
-    }
-
-    if (!hash.startsWith("$scrypt$")) return true;
-
-    const parts = hash.split("$");
-    if (parts.length !== 5) return true;
-
-    const paramsStr = parts[2];
-    const targetN = options.N || 16384;
-    const targetR = options.r || 8;
-    const targetP = options.p || 1;
-
-    return !paramsStr.includes(`N=${targetN},r=${targetR},p=${targetP}`);
-  }
-}
-
-export default Hash;
+import crypto from "node:crypto";
+
+let bcryptModule = null;
+try {
+  bcryptModule = (await import("bcrypt")).default || (await import("bcrypt"));
+} catch {
+  // bcrypt not installed, scrypt native is used
+}
+
+/**
+ * High-performance Password Hashing class.
+ * Uses native node:crypto scrypt by default (zero npm dependencies, NIST recommended),
+ * with seamless support for bcrypt when installed or verifying bcrypt hashes.
+ */
+class Hash {
+  /**
+   * Hashes a plain text password using scrypt (default) or bcrypt.
+   * @param {string} password - The plain text password.
+   * @param {Object} [options={}] - Hashing options.
+   * @param {string} [options.driver="scrypt"] - Hashing driver ('scrypt' or 'bcrypt').
+   * @param {number} [options.rounds=10] - Salt rounds for bcrypt (if driver is 'bcrypt').
+   * @param {number} [options.N=16384] - CPU/memory cost parameter for scrypt.
+   * @param {number} [options.r=8] - Block size for scrypt.
+   * @param {number} [options.p=1] - Parallelization parameter for scrypt.
+   * @returns {Promise<string>} Formatted password hash string.
+   * @example
+   * const hash = await Hash.make("mySecretPassword");
+   * // Using bcrypt:
+   * const bcryptHash = await Hash.make("mySecretPassword", { driver: "bcrypt" });
+   */
+  static async make(password, options = {}) {
+    if (typeof password !== "string" || !password) {
+      throw new Error("[HASH ERROR] Password must be a non-empty string.");
+    }
+
+    const driver = (options.driver || "scrypt").toLowerCase();
+
+    if (driver === "bcrypt") {
+      if (!bcryptModule) {
+        throw new Error(
+          "[HASH ERROR] 'bcrypt' package is not installed. Run 'npm install bcrypt' or 'npx blue-bird add bcrypt', or use the default scrypt driver.",
+        );
+      }
+      const rounds = options.rounds || 10;
+      return bcryptModule.hash(password, rounds);
+    }
+
+    // Default: native scrypt with random salt
+    const N = options.N || 16384;
+    const r = options.r || 8;
+    const p = options.p || 1;
+    const keylen = 64;
+    const salt = crypto.randomBytes(16);
+
+    return new Promise((resolve, reject) => {
+      crypto.scrypt(
+        password,
+        salt,
+        keylen,
+        { N, r, p, maxmem: 32 * 1024 * 1024 },
+        (err, derivedKey) => {
+          if (err) return reject(err);
+          const hashString = `$scrypt$N=${N},r=${r},p=${p}$${salt.toString("hex")}$${derivedKey.toString("hex")}`;
+          resolve(hashString);
+        },
+      );
+    });
+  }
+
+  /**
+   * Alias for make().
+   * @param {string} password - The plain text password.
+   * @param {Object} [options={}] - Options.
+   * @returns {Promise<string>}
+   */
+  static async hash(password, options = {}) {
+    return this.make(password, options);
+  }
+
+  /**
+   * Verifies a plain text password against a hash string.
+   * Automatically detects scrypt or bcrypt hash formats.
+   * Uses timing-safe comparison to protect against side-channel attacks.
+   *
+   * @param {string} password - The plain text password to check.
+   * @param {string} hash - The stored hash string.
+   * @returns {Promise<boolean>} True if password matches, false otherwise.
+   * @example
+   * const isValid = await Hash.verify("mySecretPassword", storedHash);
+   */
+  static async verify(password, hash) {
+    if (
+      typeof password !== "string" ||
+      !password ||
+      typeof hash !== "string" ||
+      !hash
+    ) {
+      return false;
+    }
+
+    // 1. Detect bcrypt hash format ($2a$, $2b$, $2y$)
+    if (/^\$2[aby]\$\d{2}\$/.test(hash)) {
+      if (!bcryptModule) {
+        console.error(
+          "[HASH ERROR] A bcrypt hash was detected, but the 'bcrypt' package is not installed. Run 'npm install bcrypt' or 'npx blue-bird add bcrypt'.",
+        );
+        return false;
+      }
+      try {
+        return await bcryptModule.compare(password, hash);
+      } catch {
+        return false;
+      }
+    }
+
+    // 2. Detect native scrypt format ($scrypt$N=...,r=...,p=...$salt$hash)
+    if (hash.startsWith("$scrypt$")) {
+      const parts = hash.split("$");
+      // Format: ["", "scrypt", "N=16384,r=8,p=1", "saltHex", "hashHex"]
+      if (parts.length !== 5) return false;
+
+      const paramsStr = parts[2];
+      const saltHex = parts[3];
+      const originalHashHex = parts[4];
+
+      if (!paramsStr || !saltHex || !originalHashHex) return false;
+
+      let N = 16384,
+        r = 8,
+        p = 1;
+      paramsStr.split(",").forEach((param) => {
+        const [k, v] = param.split("=");
+        if (k === "N") N = parseInt(v, 10) || N;
+        if (k === "r") r = parseInt(v, 10) || r;
+        if (k === "p") p = parseInt(v, 10) || p;
+      });
+
+      const salt = Buffer.from(saltHex, "hex");
+      const originalHash = Buffer.from(originalHashHex, "hex");
+
+      return new Promise((resolve) => {
+        crypto.scrypt(
+          password,
+          salt,
+          originalHash.length,
+          { N, r, p, maxmem: 32 * 1024 * 1024 },
+          (err, derivedKey) => {
+            if (err) return resolve(false);
+            try {
+              const matches = crypto.timingSafeEqual(originalHash, derivedKey);
+              resolve(matches);
+            } catch {
+              resolve(false);
+            }
+          },
+        );
+      });
+    }
+
+    return false;
+  }
+
+  /**
+   * Alias for verify().
+   * @param {string} password - The plain text password.
+   * @param {string} hash - The stored hash string.
+   * @returns {Promise<boolean>}
+   */
+  static async check(password, hash) {
+    return this.verify(password, hash);
+  }
+
+  /**
+   * Checks if a given hash needs to be rehashed to match updated security parameters.
+   * @param {string} hash - The stored hash string.
+   * @param {Object} [options={}] - Target options.
+   * @returns {boolean} True if the hash should be regenerated.
+   */
+  static needsRehash(hash, options = {}) {
+    if (!hash || typeof hash !== "string") return true;
+    const targetDriver = (options.driver || "scrypt").toLowerCase();
+
+    if (targetDriver === "bcrypt") {
+      return !/^\$2[aby]\$\d{2}\$/.test(hash);
+    }
+
+    if (!hash.startsWith("$scrypt$")) return true;
+
+    const parts = hash.split("$");
+    if (parts.length !== 5) return true;
+
+    const paramsStr = parts[2];
+    const targetN = options.N || 16384;
+    const targetR = options.r || 8;
+    const targetP = options.p || 1;
+
+    return !paramsStr.includes(`N=${targetN},r=${targetR},p=${targetP}`);
+  }
+}
+
+export default Hash;

package/core/index.d.ts

@@ -190,5 +190,12 @@ export class Database {
   close(): Promise<void>;
 }
 
+export class Queue {
+  static process(jobName: string, handler: (payload: any) => Promise<any> | any): void;
+  static dispatch(jobName: string, payload?: any, options?: { delayMs?: number }): Promise<boolean>;
+  static loadJobs(jobsDir?: string): Promise<void>;
+}
+
 export default App;
 
+

package/core/queue.js

@@ -0,0 +1,121 @@
+import fs from "node:fs";
+import path from "node:path";
+import { getRedisClient } from "./cache.js";
+
+/**
+ * Lightweight background queue worker module with Redis and in-memory fallback.
+ */
+class QueueManager {
+  constructor() {
+    this.handlers = new Map();
+    this.memoryQueue = [];
+    this.isProcessing = false;
+    this.redisPrefix = "bluebird:queue:";
+  }
+
+  /**
+   * Registers a job handler function.
+   * @param {string} jobName - Name of the job.
+   * @param {Function} handler - Async function(payload).
+   */
+  process(jobName, handler) {
+    if (typeof handler !== "function") {
+      throw new Error(`Handler for job '${jobName}' must be a function.`);
+    }
+    this.handlers.set(jobName, handler);
+  }
+
+  /**
+   * Dispatches a new job to the queue.
+   * @param {string} jobName - Name of the job.
+   * @param {any} payload - Data payload to pass to the handler.
+   * @param {object} [options] - Options (e.g. delayMs).
+   * @returns {Promise<boolean>}
+   */
+  async dispatch(jobName, payload = {}, options = {}) {
+    const jobItem = {
+      id: `${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+      name: jobName,
+      payload,
+      createdAt: new Date().toISOString(),
+    };
+
+    const redis = getRedisClient();
+    if (redis && redis.isReady) {
+      try {
+        await redis.lPush(`${this.redisPrefix}jobs`, JSON.stringify(jobItem));
+        return true;
+      } catch (err) {
+        console.error("[QUEUE ERROR] Failed to dispatch job to Redis:", err.message);
+      }
+    }
+
+    // In-memory fallback
+    if (options.delayMs && options.delayMs > 0) {
+      setTimeout(() => {
+        this.memoryQueue.push(jobItem);
+        this.runMemoryWorker();
+      }, options.delayMs);
+    } else {
+      this.memoryQueue.push(jobItem);
+      setImmediate(() => this.runMemoryWorker());
+    }
+
+    return true;
+  }
+
+  /**
+   * Executes in-memory queue jobs sequentially.
+   * @private
+   */
+  async runMemoryWorker() {
+    if (this.isProcessing || this.memoryQueue.length === 0) return;
+    this.isProcessing = true;
+
+    while (this.memoryQueue.length > 0) {
+      const job = this.memoryQueue.shift();
+      if (!job) continue;
+
+      const handler = this.handlers.get(job.name);
+      if (!handler) {
+        console.warn(`[QUEUE WARN] No handler registered for job '${job.name}'.`);
+        continue;
+      }
+
+      try {
+        await handler(job.payload);
+      } catch (err) {
+        console.error(`[QUEUE ERROR] Error processing job '${job.name}' (${job.id}):`, err);
+      }
+    }
+
+    this.isProcessing = false;
+  }
+
+  /**
+   * Auto-loads all job definition files from backend/jobs/.
+   */
+  async loadJobs(jobsDir = path.resolve(process.cwd(), "backend/jobs")) {
+    if (!fs.existsSync(jobsDir)) return;
+
+    const files = fs
+      .readdirSync(jobsDir)
+      .filter((f) => f.endsWith(".js") || f.endsWith(".mjs"));
+
+    for (const file of files) {
+      const fullPath = path.join(jobsDir, file);
+      try {
+        const module = await import(`file://${fullPath}`);
+        if (typeof module.default === "function") {
+          const jobName = path.basename(file, path.extname(file));
+          this.process(jobName, module.default);
+        }
+      } catch (err) {
+        console.error(`[QUEUE ERROR] Failed to load job file '${file}':`, err.message);
+      }
+    }
+  }
+}
+
+export const Queue = new QueueManager();
+export default Queue;

package/core/validate.js

@@ -148,19 +148,20 @@ class Validator {
    * const result = await loginValidator.validate(req);
    */
   async validate(req) {
+    const isExpressReq = req && (req.body !== undefined || req.headers !== undefined);
     let lang =
       req?.body?.lang ||
       req?.query?.lang ||
       req?.params?.lang ||
       req?.cookies?.lang ||
-      req?.headers["accept-language"]?.split(",")[0]?.split("-")[0] ||
+      req?.headers?.["accept-language"]?.split(",")[0]?.split("-")[0] ||
       req?.session?.lang ||
       this.lang_default ||
       "es";
     const msg = this.messages[lang] || this.messages.es;
     const errors = [];
     const messages = [];
-    const body = req.body || {};
+    const body = isExpressReq ? (req.body || {}) : (req || {});
 
     for (const [field, config] of Object.entries(this.schema)) {
       let value = body[field];

package/docker/docker-compose.mysql.yml

@@ -54,6 +54,16 @@ services:
       - "${DB_PORT:-3306}:3306"
     volumes:
       - mysql_data:/var/lib/mysql
+    command: >
+      --default-authentication-plugin=mysql_native_password
+      --character-set-server=utf8mb4
+      --collation-server=utf8mb4_unicode_ci
+      --performance-schema=OFF
+      --innodb-buffer-pool-size=64M
+      --innodb-log-buffer-size=8M
+      --max-connections=50
+      --table-open-cache=200
+      --skip-log-bin
     healthcheck:
       test: [ "CMD", "mysqladmin", "ping", "-h", "localhost", "-u", "root", "-p${DB_PASSWORD:-root}" ]
       interval: 10s