@seip/blue-bird 0.9.0 → 0.9.1

package/README.md

@@ -2,7 +2,7 @@
 
 **High-Performance Express Framework — Built for Speed, Caching, and Visual Excellence**
 
-![Blue Bird Logo](https://seip25.github.io/Blue-bird/favicon.png)
+![Blue Bird Logo](https://seip25.github.io/Blue-bird/favicon.ico)
 
 [![npm version](https://img.shields.io/npm/v/@seip/blue-bird.svg)](https://www.npmjs.com/package/@seip/blue-bird)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
@@ -95,7 +95,34 @@ project/
 
 ## 📖 Core Modules Documentation / Documentación de Módulos
 
-### 1. Routing (`Router`)
+### 1. Application Class (`App`)
+
+Initializes the Express server. If Docker/Nginx is not used (or for lightweight setups like Express + SQLite), you can configure Express to serve static frontend files directly via the `static` parameter:
+
+```javascript
+import App from "@seip/blue-bird/core/app.js";
+import routerApi from "./backend/routes/api.js";
+
+const app = new App({
+  port: process.env.PORT || 3000,
+  host: "http://localhost",
+  routes: [routerApi],
+  cors: [],
+  middlewares: [],
+  logger: false,
+  // Standalone Express Static Asset Serving (No Nginx/Docker required)
+  static: {
+    path: "../frontend", // relative directory path to frontend files
+    options: {}           // express.static options
+  }
+});
+
+app.run();
+```
+
+---
+
+### 2. Routing (`Router`)
 
 Do not use Express' native router. Always use Blue Bird's wrapper class:
 
@@ -135,57 +162,86 @@ routerApi.post("/users", validateUser.middleware(), (req, res) => {
 
 ---
 
-### 4. JWT Authentication (`Auth`)
+### 4. JWT Authentication & Redis Sessions (`Auth`)
 
-Secure user sessions using stateless AES-256-GCM encrypted JWTs stored in secure HTTP-Only cookies.
+Secure user authentication with AES-256-GCM encrypted tokens. Transmitted via HTTP-Only cookies or `Authorization` headers, with optional Redis session storage and invalidation.
 
 #### Protecting Routes
 
 ```javascript
 import Auth from "@seip/blue-bird/core/auth.js";
 
-// Secure API endpoint (returns 401 on failure)
+// 1. Secure API endpoint (returns 401 JSON on failure)
 router.get("/profile", Auth.protect(), (req, res) => {
   res.json({ user: req.user });
 });
 
-// Secure web page (redirects to /login on failure)
-router.get("/dashboard", Auth.protect({ redirect: "/login" }), (req, res) => {
-  Template.render(res, "dashboard");
+// 2. Secure web page (redirects to /login on failure)
+router.get("/dashboard", Auth.protect({ redirect: "/login", key: "user", cookieKey: "auth" }), (req, res) => {
+  res.send(`<h1>Welcome ${req.user.name}</h1>`);
 });
 ```
 
-#### Authentication Sessions
+#### Authentication Sessions & Utilities
 
 ```javascript
+// Login & Sync Session state in Redis (if active)
 router.post("/login", async (req, res) => {
-  const user = { id: 1, name: "John Doe" };
-  await Auth.login(res, user);
+  const user = { id: 1, name: "John Doe", role: "admin" };
+  await Auth.login(res, user, "auth", { expiresIn: "7d" });
   res.json({ message: "Logged in successfully" });
 });
 
+// Logout & Delete Session from Redis
 router.post("/logout", async (req, res) => {
-  await Auth.logout(res);
+  await Auth.logout(res, "auth", {}, req);
   res.json({ message: "Logged out" });
 });
+
+// Manual Encrypted JWT Tokens & AES-256-GCM Encryption
+const token = Auth.generateToken({ id: 1 }, process.env.JWT_SECRET, "2h");
+const decoded = Auth.verifyToken(token, process.env.JWT_SECRET);
+const encrypted = Auth.encrypt({ secret: "1234" }, process.env.JWT_SECRET);
+const decrypted = Auth.decrypt(encrypted, process.env.JWT_SECRET);
 ```
 
 ---
 
-### 5. Performance Cache Middleware (`Cache`)
+### 5. Performance Cache & Redis Client (`Cache`)
+
+Applies route-level response caching for JSON payloads (`res.json`) and HTML output (`res.send`). Automatically uses Redis when `REDIS_HOST` is configured, and transparently degrades to an in-memory cache if Redis is unavailable or offline.
 
-Applies caching at the route handler level. Automatically caches JSON payloads (`res.json`) and rendered outputs (`res.send`).
+#### Route Caching Middleware
 
 ```javascript
-import Cache from "@seip/blue-bird/core/cache.js";
+import Cache, { getRedisClient } from "@seip/blue-bird/core/cache.js";
 
-// Cache endpoint for 60 seconds
+// Cache endpoint for 60 seconds (sets X-Blue-Bird-Cache: HIT/MISS headers)
 router.get("/stats", Cache.middleware(60), (req, res) => {
   res.json({ usersOnline: 42 });
 });
 ```
 
-Integrates with Redis if `REDIS_HOST` is defined in the environment. Falls back to an in-memory cache automatically if Redis is not configured or not running.
+#### Custom Database & Data Caching with `getRedisClient()`
+
+```javascript
+// Direct access to the active Redis client for database query or custom key caching
+router.get("/custom-cache", async (req, res) => {
+  const redis = getRedisClient();
+  if (redis) {
+    const cached = await redis.get("my_custom_key");
+    if (cached) return res.json(JSON.parse(cached));
+
+    const dbData = await fetchHeavyDataFromDB();
+    await redis.set("my_custom_key", JSON.stringify(dbData), { EX: 120 }); // Expiry 120s
+    return res.json(dbData);
+  }
+  
+  // Fallback if Redis is disabled
+  const dbData = await fetchHeavyDataFromDB();
+  res.json(dbData);
+});
+```
 
 ---
 
@@ -269,8 +325,17 @@ npx blue-bird docker <command> [options]
 - **`npx blue-bird docker ps`**: Lists running project containers and ports.
 - **`npx blue-bird docker logs [app|db|postgres|mysql]`**: Tails logs for the specified container.
 - **`npx blue-bird docker pm2 [args]`**: Runs PM2 commands inside the Node.js application container (e.g. `status`, `monit`, `reload all`).
-- **`npx blue-bird docker db`** (or `psql` / `mysql`): Connects into the container's interactive database shell (`psql` for PostgreSQL, `mysql` for MySQL) using credentials from `.env`.
-- **`npx blue-bird docker redis`**: Connects into the container's interactive Redis CLI terminal.
+- **`npx blue-bird docker db`** (or `psql` / `mysql`): Connects into the container's interactive database shell (`psql` for PostgreSQL, `mysql` for MySQL). Supports smart table queries, schema inspection, and backups:
+  - `npx blue-bird docker mysql users` -> executes `SELECT * FROM users;` formatted as ASCII table.
+  - `npx blue-bird docker mysql users --limit=10 --where="id > 5"` -> executes filtered query.
+  - `npx blue-bird docker mysql tables` -> lists database tables (`SHOW TABLES`).
+  - `npx blue-bird docker mysql columns users` -> describes table schema (`SHOW COLUMNS`).
+- **`npx blue-bird docker export [filename.sql]`** (or `npx blue-bird docker mysql export`): Dumps database schema and data into `backups/backup_YYYY-MM-DD.sql` (creates `backups/` folder automatically).
+- **`npx blue-bird docker import [filename.sql]`** (or `npx blue-bird docker mysql import`): Restores database from a `.sql` file in `backups/` (uses the most recent `.sql` backup if no filename is specified).
+- **`npx blue-bird docker redis`**: Connects into the container's interactive Redis CLI terminal. Supports smart subcommands:
+  - `npx blue-bird docker redis monitor` -> live stream of all incoming Redis commands.
+  - `npx blue-bird docker redis keys [pattern]` -> lists all matching Redis keys (defaults to `*`).
+  - `npx blue-bird docker redis key <keyname>` -> gets value for specific Redis key.
 - **`npx blue-bird docker prune`**: Safely clears orphaned volumes, dangling build caches, and images.
 
 ---

package/core/cli/docker.js

@@ -278,7 +278,12 @@ async function logsCommand(service, followOpt) {
  * @param {boolean} rootOpt - Flag for overriding database credentials to connect as root/postgres.
  * @param {string} explicitService - Explicit target service if specified ('mysql' or 'postgres').
  */
-async function dbClientCommand(userOpt, passOpt, dbOpt, rootOpt, explicitService) {
+/**
+ * Handles interactive shell connections or smart queries into the MySQL or PostgreSQL container.
+ * @param {string[]} clientArgs - CLI arguments.
+ * @param {string} explicitService - Explicit target service if specified ('mysql', 'postgres', 'psql', 'db').
+ */
+async function dbClientCommand(clientArgs = [], explicitService) {
   checkComposeFile();
   const env = getEnvVars();
   const dbType = explicitService === "postgres" || explicitService === "psql" ? "postgres" : (explicitService === "mysql" ? "mysql" : getDbType(env));
@@ -287,25 +292,111 @@ async function dbClientCommand(userOpt, passOpt, dbOpt, rootOpt, explicitService
     return;
   }
 
+  let userOpt, passOpt, dbOpt, rootOpt = false;
+  let limitOpt = null, whereOpt = null;
+  const positionalArgs = [];
+
+  for (let i = 0; i < clientArgs.length; i++) {
+    const arg = clientArgs[i];
+    if (arg === "-u" || arg === "--user") {
+      userOpt = clientArgs[++i];
+    } else if (arg.startsWith("--user=")) {
+      userOpt = arg.split("=")[1];
+    } else if (arg === "-p" || arg === "--password") {
+      passOpt = clientArgs[++i];
+    } else if (arg.startsWith("--password=")) {
+      passOpt = arg.split("=")[1];
+    } else if (arg === "-d" || arg === "--db") {
+      dbOpt = clientArgs[++i];
+    } else if (arg.startsWith("--db=")) {
+      dbOpt = arg.split("=")[1];
+    } else if (arg === "--root") {
+      rootOpt = true;
+    } else if (arg === "--limit" || arg === "-l") {
+      limitOpt = clientArgs[++i];
+    } else if (arg.startsWith("--limit=")) {
+      limitOpt = arg.split("=")[1];
+    } else if (arg === "--where" || arg === "-w") {
+      whereOpt = clientArgs[++i];
+    } else if (arg.startsWith("--where=")) {
+      whereOpt = arg.split("=")[1];
+    } else if (!arg.startsWith("-")) {
+      positionalArgs.push(arg);
+    }
+  }
+
   let dbUser = userOpt;
   let dbPass = passOpt;
   let dbName = dbOpt;
 
-  if (dbType === "postgres") {
-    if (rootOpt) {
-      dbUser = "postgres";
+  let sqlQuery = null;
+  if (positionalArgs.length > 0) {
+    const firstPos = positionalArgs[0].toLowerCase();
+
+    if (firstPos === "export" || firstPos === "dump") {
+      await exportDbCommand(dbType, positionalArgs[1], userOpt, passOpt, dbOpt);
+      return;
+    }
+    if (firstPos === "import" || firstPos === "restore") {
+      await importDbCommand(dbType, positionalArgs[1], userOpt, passOpt, dbOpt);
+      return;
+    }
+    if (firstPos === "tables") {
+      if (dbType === "postgres") {
+        sqlQuery = "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public';";
+      } else {
+        sqlQuery = "SHOW TABLES;";
+      }
+    } else if (firstPos === "columns" || firstPos === "cols" || firstPos === "describe" || firstPos === "desc") {
+      const tableName = positionalArgs[1];
+      if (!tableName) {
+        console.error(chalk.red("Error: Please specify a table name. Example: npx blue-bird docker mysql columns users"));
+        process.exit(1);
+      }
+      if (dbType === "postgres") {
+        sqlQuery = `SELECT column_name, data_type, is_nullable, column_default FROM information_schema.columns WHERE table_name = '${tableName}';`;
+      } else {
+        sqlQuery = `SHOW COLUMNS FROM ${tableName};`;
+      }
     } else {
-      dbUser = dbUser || env.DB_USER || "postgres";
+      const rawInput = positionalArgs.join(" ").trim();
+      const isFullQuery = /^(select|show|desc|describe|explain|insert|update|delete|create|drop|alter|truncate)\b/i.test(rawInput) || rawInput.includes(" ");
+      if (isFullQuery) {
+        sqlQuery = rawInput;
+      } else {
+        const tableName = rawInput;
+        sqlQuery = `SELECT * FROM ${tableName}`;
+        if (whereOpt) {
+          sqlQuery += ` WHERE ${whereOpt}`;
+        }
+        if (limitOpt) {
+          sqlQuery += ` LIMIT ${limitOpt}`;
+        }
+      }
+      if (!sqlQuery.endsWith(";")) {
+        sqlQuery += ";";
+      }
     }
-    dbName = dbName || env.DB_NAME || "blue_bird";
+  }
 
-    const targetDb = dbName ? ` (database: ${dbName})` : "";
-    console.log(chalk.cyan(`Connecting to PostgreSQL shell (psql) in container as '${dbUser}'${targetDb}...`));
+  if (dbType === "postgres") {
+    dbUser = rootOpt ? "postgres" : (dbUser || env.DB_USER || "postgres");
+    dbName = dbName || env.DB_NAME || "blue_bird";
 
     const cmdArgs = ["compose", "exec", "postgres", "psql", `-U${dbUser}`];
     if (dbName) {
       cmdArgs.push("-d", dbName);
     }
+
+    if (sqlQuery) {
+      console.log(chalk.cyan(`🔍 Executing PostgreSQL query on database '${dbName}':`));
+      console.log(chalk.gray(`   ${sqlQuery}\n`));
+      cmdArgs.push("-c", sqlQuery);
+    } else {
+      const targetDb = dbName ? ` (database: ${dbName})` : "";
+      console.log(chalk.cyan(`Connecting to PostgreSQL shell (psql) in container as '${dbUser}'${targetDb}...`));
+    }
+
     const code = await runCmd("docker", cmdArgs);
     if (code !== 0) {
       console.error(chalk.yellow("Make sure the PostgreSQL container is running: npx blue-bird docker start postgres"));
@@ -329,8 +420,14 @@ async function dbClientCommand(userOpt, passOpt, dbOpt, rootOpt, explicitService
       cmdArgs.push(dbName);
     }
 
-    const targetDb = dbName ? ` (database: ${dbName})` : "";
-    console.log(chalk.cyan(`Connecting to MySQL shell in container as '${dbUser}'${targetDb}...`));
+    if (sqlQuery) {
+      console.log(chalk.cyan(`🔍 Executing MySQL query on database '${dbName}':`));
+      console.log(chalk.gray(`   ${sqlQuery}\n`));
+      cmdArgs.push("-t", "-e", sqlQuery);
+    } else {
+      const targetDb = dbName ? ` (database: ${dbName})` : "";
+      console.log(chalk.cyan(`Connecting to MySQL shell in container as '${dbUser}'${targetDb}...`));
+    }
 
     const code = await runCmd("docker", cmdArgs);
     if (code !== 0) {
@@ -340,6 +437,196 @@ async function dbClientCommand(userOpt, passOpt, dbOpt, rootOpt, explicitService
   }
 }
 
+/**
+ * Exports database schema & data into a .sql file inside backups/ folder.
+ * @param {string} dbType - Target db type ('mysql', 'postgres', 'none').
+ * @param {string} [filenameArg] - Custom backup filename.
+ * @param {string} [userOpt] - Custom db user.
+ * @param {string} [passOpt] - Custom db password.
+ * @param {string} [dbOpt] - Custom db name.
+ */
+async function exportDbCommand(dbType, filenameArg, userOpt, passOpt, dbOpt) {
+  checkComposeFile();
+  const env = getEnvVars();
+  const targetDbType = dbType === "none" ? getDbType(env) : dbType;
+
+  if (targetDbType === "none") {
+    console.error(chalk.yellow("[INFO] DB_TYPE is set to 'none'. No database available to export."));
+    return;
+  }
+
+  const backupsDir = path.join(process.cwd(), "backups");
+  if (!fs.existsSync(backupsDir)) {
+    fs.mkdirSync(backupsDir, { recursive: true });
+  }
+
+  let outputFile;
+  if (filenameArg) {
+    let name = filenameArg;
+    if (!name.endsWith(".sql")) name += ".sql";
+    if (path.isAbsolute(name)) {
+      outputFile = name;
+    } else if (name.includes("/") || name.includes("\\")) {
+      outputFile = path.resolve(process.cwd(), name);
+    } else {
+      outputFile = path.join(backupsDir, name);
+    }
+  } else {
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19);
+    outputFile = path.join(backupsDir, `backup_${targetDbType}_${timestamp}.sql`);
+  }
+
+  const dbUser = userOpt || env.DB_USER || (targetDbType === "postgres" ? "postgres" : "root");
+  const dbPass = passOpt || env.DB_PASSWORD || (targetDbType === "postgres" ? "postgres" : "root");
+  const dbName = dbOpt || env.DB_NAME || "blue_bird";
+
+  let cmdArgs = [];
+  if (targetDbType === "postgres") {
+    cmdArgs = ["compose", "exec", "-T", "postgres", "pg_dump", `-U${dbUser}`, "-d", dbName];
+  } else {
+    cmdArgs = ["compose", "exec", "-T", "mysql", "mysqldump", `-u${dbUser}`, `-p${dbPass}`, dbName];
+  }
+
+  const relPath = path.relative(process.cwd(), outputFile);
+  console.log(chalk.cyan(`📦 Exporting ${targetDbType.toUpperCase()} database '${dbName}' to '${relPath}'...`));
+
+  const success = await exportDbToFile(cmdArgs, outputFile);
+  if (success) {
+    const stats = fs.statSync(outputFile);
+    const sizeKb = (stats.size / 1024).toFixed(2);
+    console.log(chalk.green(`\n✔ Database exported successfully!`));
+    console.log(chalk.cyan(`   File: ${relPath} (${sizeKb} KB)`));
+  } else {
+    console.error(chalk.red(`\n✖ Database export failed.`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Streams stdout from container dump command into a local file.
+ */
+function exportDbToFile(cmdArgs, outputFile) {
+  return new Promise((resolve) => {
+    const outStream = fs.createWriteStream(outputFile);
+    const proc = spawn("docker", cmdArgs, { stdio: ["inherit", "pipe", "pipe"], env: process.env });
+    proc.stdout.pipe(outStream);
+
+    let errOutput = "";
+    proc.stderr.on("data", (chunk) => {
+      errOutput += chunk.toString();
+    });
+
+    proc.on("close", (code) => {
+      outStream.close();
+      if (code === 0) {
+        resolve(true);
+      } else {
+        if (errOutput) console.error(chalk.yellow(`Warning/Stderr: ${errOutput.trim()}`));
+        resolve(code === 0);
+      }
+    });
+  });
+}
+
+/**
+ * Imports a .sql file from backups/ folder into the container database.
+ * @param {string} dbType - Target db type ('mysql', 'postgres', 'none').
+ * @param {string} [filenameArg] - Custom backup filename.
+ * @param {string} [userOpt] - Custom db user.
+ * @param {string} [passOpt] - Custom db password.
+ * @param {string} [dbOpt] - Custom db name.
+ */
+async function importDbCommand(dbType, filenameArg, userOpt, passOpt, dbOpt) {
+  checkComposeFile();
+  const env = getEnvVars();
+  const targetDbType = dbType === "none" ? getDbType(env) : dbType;
+
+  if (targetDbType === "none") {
+    console.error(chalk.yellow("[INFO] DB_TYPE is set to 'none'. No database available to import into."));
+    return;
+  }
+
+  const backupsDir = path.join(process.cwd(), "backups");
+  if (!fs.existsSync(backupsDir)) {
+    fs.mkdirSync(backupsDir, { recursive: true });
+  }
+
+  let inputFile;
+  if (filenameArg) {
+    let name = filenameArg;
+    if (!name.endsWith(".sql") && !fs.existsSync(name)) name += ".sql";
+    if (fs.existsSync(name)) {
+      inputFile = path.resolve(process.cwd(), name);
+    } else if (fs.existsSync(path.join(backupsDir, name))) {
+      inputFile = path.join(backupsDir, name);
+    } else {
+      console.error(chalk.red(`Error: Backup file '${filenameArg}' not found in current directory or 'backups/' folder.`));
+      process.exit(1);
+    }
+  } else {
+    const files = fs.readdirSync(backupsDir)
+      .filter(f => f.endsWith(".sql"))
+      .map(f => ({ name: f, time: fs.statSync(path.join(backupsDir, f)).mtimeMs }))
+      .sort((a, b) => b.time - a.time);
+
+    if (files.length === 0) {
+      console.error(chalk.red(`Error: No .sql backup files found in 'backups/' directory.`));
+      console.log(chalk.yellow(`Usage: npx blue-bird docker import <file.sql>`));
+      process.exit(1);
+    }
+
+    inputFile = path.join(backupsDir, files[0].name);
+    console.log(chalk.yellow(`[INFO] No file specified. Using most recent backup: '${files[0].name}'`));
+  }
+
+  const dbUser = userOpt || env.DB_USER || (targetDbType === "postgres" ? "postgres" : "root");
+  const dbPass = passOpt || env.DB_PASSWORD || (targetDbType === "postgres" ? "postgres" : "root");
+  const dbName = dbOpt || env.DB_NAME || "blue_bird";
+
+  let cmdArgs = [];
+  if (targetDbType === "postgres") {
+    cmdArgs = ["compose", "exec", "-T", "postgres", "psql", `-U${dbUser}`, "-d", dbName];
+  } else {
+    cmdArgs = ["compose", "exec", "-T", "mysql", "mysql", `-u${dbUser}`, `-p${dbPass}`, dbName];
+  }
+
+  const relPath = path.relative(process.cwd(), inputFile);
+  console.log(chalk.cyan(`📥 Importing SQL dump '${relPath}' into ${targetDbType.toUpperCase()} database '${dbName}'...`));
+
+  const success = await importDbFromFile(cmdArgs, inputFile);
+  if (success) {
+    console.log(chalk.green(`\n✔ Database imported successfully from '${relPath}'!`));
+  } else {
+    console.error(chalk.red(`\n✖ Database import failed.`));
+    process.exit(1);
+  }
+}
+
+/**
+ * Streams a local .sql file into container stdin.
+ */
+function importDbFromFile(cmdArgs, inputFile) {
+  return new Promise((resolve) => {
+    const inStream = fs.createReadStream(inputFile);
+    const proc = spawn("docker", cmdArgs, { stdio: ["pipe", "inherit", "pipe"], env: process.env });
+    inStream.pipe(proc.stdin);
+
+    let errOutput = "";
+    proc.stderr.on("data", (chunk) => {
+      errOutput += chunk.toString();
+    });
+
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve(true);
+      } else {
+        if (errOutput) console.error(chalk.yellow(`Warning/Stderr: ${errOutput.trim()}`));
+        resolve(code === 0);
+      }
+    });
+  });
+}
+
 /**
  * Handles cleaning up and pruning unused Docker resources.
  * @param {boolean} forceOpt - Force cleaning without user confirmation.
@@ -385,12 +672,43 @@ async function pm2Command(pm2Args = []) {
 }
 
 /**
- * Handles interactive shell connections into the Redis container.
+ * Handles interactive shell connections or smart query subcommands into the Redis container.
+ * @param {string[]} redisArgs - Subcommands or key parameters.
  */
-async function redisCommand() {
+async function redisCommand(redisArgs = []) {
   checkComposeFile();
   const cmdArgs = ["compose", "exec", "redis", "redis-cli"];
-  await runCmd("docker", cmdArgs);
+
+  if (redisArgs.length > 0) {
+    const firstArg = redisArgs[0].toLowerCase();
+
+    if (firstArg === "monitor") {
+      console.log(chalk.cyan("📡 Monitoring live Redis commands... (Press Ctrl+C to exit)"));
+      cmdArgs.push("monitor");
+    } else if (firstArg === "keys") {
+      const pattern = redisArgs[1] || "*";
+      console.log(chalk.cyan(`🔑 Fetching Redis keys matching '${pattern}'...`));
+      cmdArgs.push("keys", pattern);
+    } else if (firstArg === "key") {
+      const keyName = redisArgs[1];
+      if (!keyName) {
+        console.error(chalk.red("Error: Please specify a key name. Example: npx blue-bird docker redis key session:123"));
+        process.exit(1);
+      }
+      console.log(chalk.cyan(`📄 Getting value for Redis key '${keyName}'...`));
+      cmdArgs.push("get", keyName);
+    } else {
+      cmdArgs.push(...redisArgs);
+    }
+  } else {
+    console.log(chalk.cyan("Connecting to Redis interactive terminal (redis-cli)..."));
+  }
+
+  const code = await runCmd("docker", cmdArgs);
+  if (code !== 0) {
+    console.error(chalk.yellow("Make sure the Redis container is running: npx blue-bird docker start redis"));
+    process.exit(1);
+  }
 }
 
 /**
@@ -450,23 +768,23 @@ async function main() {
     case "pm2":
       await pm2Command(args.slice(1));
       break;
+    case "export":
+    case "dump":
+      await exportDbCommand("none", args[1]);
+      break;
+    case "import":
+    case "restore":
+      await importDbCommand("none", args[1]);
+      break;
     case "redis":
-      await redisCommand();
+      await redisCommand(args.slice(1));
       break;
     case "mysql":
     case "postgres":
     case "psql":
-    case "db": {
-      let user, password, db, root = false;
-      for (let i = 1; i < args.length; i++) {
-        if (args[i] === "-u" || args[i] === "--user") user = args[++i];
-        else if (args[i] === "-p" || args[i] === "--password") password = args[++i];
-        else if (args[i] === "-d" || args[i] === "--db") db = args[++i];
-        else if (args[i] === "--root") root = true;
-      }
-      await dbClientCommand(user, password, db, root, command);
+    case "db":
+      await dbClientCommand(args.slice(1), command);
       break;
-    }
     case "df":
     case "disk":
       console.log(chalk.cyan("📊 Docker Disk Usage:"));
@@ -481,7 +799,7 @@ async function main() {
     }
     default:
       console.log(chalk.yellow(`Unknown docker command: ${command}`));
-      console.log("Available commands: dev, start, stop, build, ps, logs, pm2, mysql/postgres/db, redis, df/disk, prune/clean");
+      console.log("Available commands: dev, start, stop, build, ps, logs, pm2, export/dump, import/restore, mysql/postgres/db, redis, df/disk, prune/clean");
   }
 }
 

package/docker/nginx.conf

@@ -66,6 +66,7 @@ http {
         }
 
         location / {
+            add_header Cache-Control "no-cache";
             try_files $uri $uri.html $uri/ @node_app;
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seip/blue-bird",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "Express opinionated API framework with built-in JWT auth, validation, and caching",
   "type": "module",
   "exports": {