@seip/blue-bird 0.6.4 → 0.7.1

package/backend/routes/api.js

@@ -1,11 +1,15 @@
 import Router from "@seip/blue-bird/core/router.js";
 import Validator from "@seip/blue-bird/core/validate.js";
 import Cache from "@seip/blue-bird/core/cache.js";
-import Auth from "@seip/blue-bird/core/auth.js"
+import Auth from "@seip/blue-bird/core/auth.js";
 
-const routerApiExample = new Router("/api");
+const routerApi = new Router("/api");
 
-routerApiExample.get("/users", (req, res) => {
+routerApi.get("//", (req, res) => {
+  res.json({ api: true, message: "Bluebird API", time: Date.now() });
+});
+
+routerApi.get("/users", (req, res) => {
   const users = [
     {
       name: "John Doe",
@@ -26,28 +30,28 @@ const loginSchema = {
 
 const loginValidator = new Validator(loginSchema);
 
-routerApiExample.post("/login", loginValidator.middleware(), (req, res) => {
+routerApi.post("/login", loginValidator.middleware(), (req, res) => {
   res.json({ message: "Login successful", body: req.body });
 });
 
-routerApiExample.get("/cache", Cache.middleware(), async (req, res) => {
-  await new Promise(resolve => setTimeout(resolve, 2000));
+routerApi.get("/cache", Cache.middleware(), async (req, res) => {
+  await new Promise((resolve) => setTimeout(resolve, 2000));
   res.json({ message: "Cache successful" });
-})
+});
 
-routerApiExample.get("/auth_generate", async (req, res) => {
-  const token = await Auth.login(res, { id: 1, name: "John Doe" })
+routerApi.get("/auth_generate", async (req, res) => {
+  const token = await Auth.login(res, { id: 1, name: "John Doe" });
   res.json({ message: "Auth successful", token });
-})
+});
 
-routerApiExample.get("/auth_logout", async (req, res) => {
-  await Auth.logout(res)
+routerApi.get("/auth_logout", async (req, res) => {
+  await Auth.logout(res);
   res.json({ message: "Auth successful" });
-})
+});
 
-routerApiExample.get("/auth_verify", Auth.protect(), (req, res) => {
-  const userInfo = req.user
+routerApi.get("/auth_verify", Auth.protect(), (req, res) => {
+  const userInfo = req.user;
   res.json({ message: "Auth successful", user: userInfo });
-})
+});
 
-export default routerApiExample;
+export default routerApi;

package/core/app.js

@@ -10,8 +10,6 @@ import compression from "compression";
 import Config from "./config.js";
 import Logger from "./logger.js";
 import Debug from "./debug.js";
-import Template from "./template.js";
-import SEO from "./seo.js";
 
 const __dirname = Config.dirname();
 const props = Config.props();
@@ -36,7 +34,8 @@ class App {
    * @param {boolean} [options.cookieParser=true] - Whether to enable cookie parsing.
    * @param {boolean|Object} [options.rateLimit=false] - Enable global rate limiting.
    * @param {boolean|Object} [options.swagger=false] - Enable swagger.
-   * @param {boolean} [options.compression=true] - Enable Gzip compression.
+   * @param {boolean} [options.compression=true] - Enable compression.
+   * @param {boolean} [options.astro=true] - Astro handler.
    * @example
    * const app = new App({
    *     routes: [],
@@ -55,7 +54,14 @@ class App {
    *         info: { title: "Blue Bird API", version: "1.0.0", description: "API Documentation" },
    *         url: "http://localhost:8000"
    *     },
-   *     compression: true
+   *     compression:true,
+   *     astro: {
+   *       server: true,
+   *       serverEntry: "./frontend/dist/server/entry.mjs",
+   *       client: false,
+   *       clientDir: "./frontend/dist/client",
+   *       base: "/"
+   *     }
    * });
    */
   constructor(options = {}) {
@@ -75,6 +81,7 @@ class App {
     this.rateLimit = options.rateLimit ?? false;
     this.swagger = options.swagger ?? false;
     this.compression = options.compression ?? true;
+    this.astro = options.astro || false;
     this.loggerInstance = new Logger();
     /** @type {Set<import('http').ServerResponse>} */
     this._hotReloadClients = new Set();
@@ -121,13 +128,16 @@ class App {
 
     if (this.static.path)
       this.app.use(
-        express.static(
-          path.join(__dirname, this.static.path),
-          { ...this.static.options, setHeaders: (res) => {
-            res.setHeader("X-Powered-By", "Blue Bird"); 
-            res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
-          }},
-        ),
+        express.static(path.join(__dirname, this.static.path), {
+          ...this.static.options,
+          setHeaders: (res) => {
+            res.setHeader("X-Powered-By", "Blue Bird");
+            res.setHeader(
+              "Cache-Control",
+              "public, max-age=31536000, immutable",
+            );
+          },
+        }),
       );
 
     this.app.use(cors(this.cors));
@@ -165,13 +175,12 @@ class App {
     if (this.logger || props.debug) this._middlewareLogger(this.logger);
 
     this.app.use((req, res, next) => {
-      res.setHeader("X-Powered-By", "Blue Bird"); 
-       next();
+      res.setHeader("X-Powered-By", "Blue Bird");
+      next();
     });
 
     if (props.debug) {
       Debug.middlewareMetrics(this.app);
-      this._setupHotReload();
     }
 
     if (this.swagger) {
@@ -196,70 +205,65 @@ class App {
 
     this._dispatchRoutes();
 
-    SEO.registerEndpoints(this.app);
-
-    if (this.notFound) this._notFoundDefault();
-
-    this._errorHandler();
-  }
-
-  /**
-   * Sets up hot-reload using Server-Sent Events (SSE).
-   * Watches the frontend/ directory for .html, .css, .js file changes and notifies connected browsers.
-   * Also clears the Template cache on file changes so fresh content is served.
-   * Only active when DEBUG=true in .env.
-   * @private
-   */
-  _setupHotReload() {
-    this.app.get("/__hot-reload", (req, res) => {
-      res.setHeader("x-no-compression", "true");
-      res.writeHead(200, {
-        "Content-Type": "text/event-stream",
-        "Cache-Control": "no-cache",
-        "Connection": "keep-alive",
-        "X-Accel-Buffering": "no",
-      });
-      res.write("data: connected\n\n");
-      if (typeof res.flush === "function") {
-        res.flush();
+    if (this.astro) {
+      const defaultAstro = {
+        server: true,
+        serverEntry: "./frontend/dist/server/entry.mjs",
+        client: false,
+        clientDir: "./frontend/dist/client",
+        base: "/",
+      };
+      const astroConfig =
+        typeof this.astro === "object"
+          ? { ...defaultAstro, ...this.astro }
+          : { ...defaultAstro };
+
+      if (astroConfig.client) {
+        const clientPath = path.resolve(astroConfig.clientDir);
+        if (fs.existsSync(clientPath)) {
+          this.app.use(astroConfig.base, express.static(clientPath));
+          console.log(
+            chalk.green(
+              `[OK] Astro Static Client Assets registered at ${astroConfig.base}`,
+            ),
+          );
+        } else {
+          console.warn(
+            chalk.yellow(
+              `[WARN] Astro client directory not found at: ${clientPath}`,
+            ),
+          );
+        }
       }
-      this._hotReloadClients.add(res);
-      req.on("close", () => {
-        this._hotReloadClients.delete(res);
-      });
-    });
 
-    const frontendPath = path.join(__dirname, "frontend");
-    let debounceTimer = null;
-
-    const notifyClients = () => {
-      this._hotReloadClients.forEach((client) => {
-        try {
-          client.write("data: reload\n\n");
-          if (typeof client.flush === "function") {
-            client.flush();
+      if (astroConfig.server) {
+        const entryPath = path.resolve(astroConfig.serverEntry);
+        if (fs.existsSync(entryPath)) {
+          try {
+            const { handler: ssrHandler } = await import(entryPath);
+            this.app.use(ssrHandler);
+            console.log(
+              chalk.green("[OK] Astro SSR Handler registered successfully."),
+            );
+          } catch (error) {
+            console.error(
+              chalk.red("[ERROR] Failed to load Astro SSR Handler:"),
+              error.message,
+            );
           }
-        } catch (_) {
-          this._hotReloadClients.delete(client);
-        }
-      });
-    };
-
-    try {
-      fs.watch(frontendPath, { recursive: true }, (eventType, filename) => {
-        if (!filename) return;
-        if (/\.(html|css|js)$/i.test(filename)) {
-          if (debounceTimer) clearTimeout(debounceTimer);
-          debounceTimer = setTimeout(() => {
-            console.log(chalk.magenta(`[Hot Reload] ${filename} changed`));
-            Template.clearCache();
-            notifyClients();
-          }, 200);
+        } else {
+          console.warn(
+            chalk.yellow(
+              `[WARN] Astro build entrypoint not found at: ${entryPath}`,
+            ),
+          );
         }
-      });
-    } catch (_) {
-      console.log(chalk.yellow("[Hot Reload] Could not watch frontend/ directory"));
+      }
     }
+
+    if (this.notFound) this._notFoundDefault();
+
+    this._errorHandler();
   }
 
   /**
@@ -279,6 +283,7 @@ class App {
         Object.keys(req.params).length > 0
           ? ` ${JSON.stringify(req.params)}`
           : "";
+
       const ip = req.ip;
       const now = new Date().toISOString();
       const time = `${now.split("T")[0]} ${now.split("T")[1].split(".")[0]}`;
@@ -357,14 +362,14 @@ class App {
         this.app.listen(this.port, () => {
           console.log(
             chalk.bold.blue("Blue Bird Server Online\n") +
-            chalk.bold.cyan("App URL: ") +
-            chalk.green(`${this.appUrl}`) +
-            "\n" +
-            chalk.bold.cyan("Internal: ") +
-            chalk.green(`${this.host}:${this.port}`) +
-            "\n" +
-            (props.debug ? chalk.bold.magenta("Hot Reload: enabled\n") : "") +
-            chalk.gray("────────────────────────────────"),
+              chalk.bold.cyan("App URL: ") +
+              chalk.green(`${this.appUrl}`) +
+              "\n" +
+              chalk.bold.cyan("Internal: ") +
+              chalk.green(`${this.host}:${this.port}`) +
+              "\n" +
+              (props.debug ? chalk.bold.magenta("Hot Reload: enabled\n") : "") +
+              chalk.gray("────────────────────────────────"),
           );
         });
       })

package/core/cache.js

@@ -1,38 +1,101 @@
+import fs from "node:fs";
+
 const CACHE = {};
 
+let redisClient = null;
+let isRedisConnected = false;
+const redisHost = process.env.REDIS_HOST ?? false;
+const redisPort = process.env.REDIS_PORT ?? 6379;
+const redisPassword = process.env.REDIS_PASSWORD || "";
+const redisUrl = redisPassword
+  ? `redis://:${redisPassword}@${redisHost}:${redisPort}`
+  : `redis://${redisHost}:${redisPort}`;
+
+/**
+ * Initializes the Redis client connection if REDIS_HOST env is set.
+ * @returns {Promise<void>}
+ */
+async function initRedis() {
+  if (redisClient) return;
+  if (!redisHost) return;
+
+  try {
+    const { createClient } = await import("redis");
+    let host = redisHost;
+    if (host === "localhost" && fs.existsSync("/.dockerenv")) {
+      host = "redis";
+    }
+    const url = redisUrl;
+
+    redisClient = createClient({ url });
+    redisClient.on("error", () => {
+      isRedisConnected = false;
+    });
+    await redisClient.connect();
+    isRedisConnected = true;
+  } catch (err) {
+    redisClient = null;
+    isRedisConnected = false;
+  }
+}
+
+initRedis().catch(() => {});
+
 setInterval(() => {
-    const now = Date.now();
-    for (const key in CACHE) {
-        if (CACHE[key].expiry <= now) {
-            delete CACHE[key];
-        }
+  const now = Date.now();
+  for (const key in CACHE) {
+    if (CACHE[key].expiry <= now) {
+      delete CACHE[key];
     }
+  }
 }, 300000).unref();
+
 /**
- * Simple in-memory Cache class to provide middleware for Express routes.
- * Caches JSON responses based on the request URL.
+ * High-performance Caching class supporting both local memory and Redis backends.
  */
 class Cache {
   /**
-   * Middleware to cache responses.
-   * @param {number} [seconds=60] - Number of seconds to cache the response.
-   * @returns {Function} Express middleware function.
-   * @example
-   * router.get("/stats", Cache.middleware(120), (req, res) => {
-   *     res.json({ ok: true });
-   * });
+   * Express middleware to cache route JSON and HTML responses.
+   * @param {number} [seconds=60] - Expiry time in seconds.
+   * @returns {Function} Express middleware.
    */
   static middleware(seconds = 60) {
-    return (req, res, next) => {
+    return async (req, res, next) => {
       const key = req.originalUrl;
 
-      if (CACHE[key] && CACHE[key].expiry > Date.now()) {
-        const cached = CACHE[key];
-        if (cached.type === "json") {
-          return res.json(cached.data);
-        } else {
-          res.type("text/html");
-          return res.send(cached.data);
+      if (redisHost && !redisClient) {
+        await initRedis().catch(() => {});
+      }
+
+      if (isRedisConnected && redisClient) {
+        try {
+          const cachedData = await redisClient.get(key);
+          if (cachedData) {
+            const cached = JSON.parse(cachedData);
+            if (cached.type === "json") {
+              return res.json(cached.data);
+            } else {
+              res.type("text/html");
+              res.set("X-Blue-Bird-Cache", "HIT");
+              return res.send(cached.data);
+            }
+          }
+        } catch (err) {
+          isRedisConnected = false;
+        }
+      }
+
+      if (!isRedisConnected || !redisClient) {
+        if (CACHE[key] && CACHE[key].expiry > Date.now()) {
+          const cached = CACHE[key];
+          if (cached.type === "json") {
+            res.set("X-Blue-Bird-Cache", "HIT");
+            return res.json(cached.data);
+          } else {
+            res.type("text/html");
+            res.set("X-Blue-Bird-Cache", "HIT");
+            return res.send(cached.data);
+          }
         }
       }
 
@@ -40,33 +103,58 @@ class Cache {
       const originalSend = res.send.bind(res);
       let cachedInRequest = false;
 
-      res.json = (body) => {
+      res.json = async (body) => {
         if (!cachedInRequest) {
-          CACHE[key] = {
+          cachedInRequest = true;
+          const cacheObject = {
             type: "json",
             data: body,
             expiry: Date.now() + seconds * 1000,
           };
-          cachedInRequest = true;
+          if (isRedisConnected && redisClient) {
+            try {
+              await redisClient.set(key, JSON.stringify(cacheObject), {
+                EX: seconds,
+              });
+            } catch (err) {
+              CACHE[key] = cacheObject;
+            }
+          } else {
+            CACHE[key] = cacheObject;
+          }
         }
+        res.set("X-Blue-Bird-Cache", "MISS");
         return originalJson(body);
       };
 
-      res.send = (body) => {
+      res.send = async (body) => {
         if (!cachedInRequest && typeof body === "string") {
-          CACHE[key] = {
+          cachedInRequest = true;
+          const cacheObject = {
             type: "html",
             data: body,
             expiry: Date.now() + seconds * 1000,
           };
-          cachedInRequest = true;
+          if (isRedisConnected && redisClient) {
+            try {
+              await redisClient.set(key, JSON.stringify(cacheObject), {
+                EX: seconds,
+              });
+            } catch (err) {
+              CACHE[key] = cacheObject;
+            }
+          } else {
+            CACHE[key] = cacheObject;
+          }
         }
+        res.set("X-Blue-Bird-Cache", "MISS");
         return originalSend(body);
       };
 
+      res.set("X-Blue-Bird-Cache", "MISS");
       next();
     };
   }
 }
 
-export default Cache;
+export default Cache;

package/core/cli/docker.js

@@ -58,27 +58,43 @@ async function startCommand(service) {
   checkComposeFile();
 
   if (service === "mysql" || service === "--mysql" || service === "dev") {
-    console.log(chalk.cyan("Starting MySQL container (dev mode)..."));
+    console.log(chalk.cyan("Starting MySQL container..."));
     const code = await runCmd("docker", ["compose", "up", "-d", "mysql"]);
     if (code === 0) {
-      console.log(chalk.green("MySQL started. Run your app locally with: npm run dev"));
-      console.log(chalk.blue("To also run the app in Docker (production), use: npx blue-bird docker start prod"));
+      console.log(chalk.green("MySQL started."));
     } else {
       console.error(chalk.red("Error starting MySQL."));
       process.exit(1);
     }
+  } else if (service === "redis" || service === "--redis") {
+    console.log(chalk.cyan("Starting Redis container..."));
+    const code = await runCmd("docker", ["compose", "up", "-d", "redis"]);
+    if (code === 0) {
+      console.log(chalk.green("Redis started."));
+    } else {
+      console.error(chalk.red("Error starting Redis."));
+      process.exit(1);
+    }
+  } else if (service === "dbs" || service === "databases") {
+    console.log(chalk.cyan("Starting Database containers (MySQL + Redis)..."));
+    const code = await runCmd("docker", ["compose", "up", "-d", "mysql", "redis"]);
+    if (code === 0) {
+      console.log(chalk.green("Database containers started."));
+    } else {
+      console.error(chalk.red("Error starting databases."));
+      process.exit(1);
+    }
   } else if (service === "prod" || service === "app" || service === "--app" || !service) {
-    console.log(chalk.cyan("Starting production stack (MySQL + Node.js app)..."));
+    console.log(chalk.cyan("Starting production stack (MySQL + Redis + App + Nginx)..."));
     const code = await runCmd("docker", ["compose", "--profile", "prod", "up", "-d"]);
     if (code === 0) {
       console.log(chalk.green("Production stack started."));
-      console.log(chalk.blue("View logs with: npx blue-bird docker logs"));
     } else {
       console.error(chalk.red("Error starting production stack."));
       process.exit(1);
     }
   } else {
-    console.error(chalk.red(`Unknown service '${service}'. Use: mysql (or --mysql), prod (or --app), or no arguments for both.`));
+    console.error(chalk.red(`Unknown service '${service}'. Use: mysql, redis, dbs, prod.`));
     process.exit(1);
   }
 }
@@ -99,13 +115,18 @@ async function stopCommand(service) {
     await runCmd("docker", ["compose", "stop", "mysql"]);
     await runCmd("docker", ["compose", "rm", "-f", "mysql"]);
     console.log(chalk.green("MySQL stopped."));
+  } else if (service === "redis" || service === "--redis") {
+    console.log(chalk.cyan("Stopping Redis..."));
+    await runCmd("docker", ["compose", "stop", "redis"]);
+    await runCmd("docker", ["compose", "rm", "-f", "redis"]);
+    console.log(chalk.green("Redis stopped."));
   } else if (service === "app" || service === "--app") {
     console.log(chalk.cyan("Stopping Node.js app container..."));
     await runCmd("docker", ["compose", "--profile", "prod", "stop", "app"]);
     await runCmd("docker", ["compose", "--profile", "prod", "rm", "-f", "app"]);
     console.log(chalk.green("App container stopped."));
   } else {
-    console.error(chalk.red(`Unknown service '${service}'. Use: all (default), mysql, app.`));
+    console.error(chalk.red(`Unknown service '${service}'. Use: all, mysql, redis, app.`));
     process.exit(1);
   }
 }
@@ -235,6 +256,21 @@ async function pruneCommand(forceOpt, allOpt) {
   await runCmd("docker", ["system", "df"]);
 }
 
+/**
+ * Executes PM2 commands inside the Node.js application container.
+ * @param {string[]} pm2Args - Arguments to pass to PM2.
+ */
+async function pm2Command(pm2Args = []) {
+  checkComposeFile();
+  const subCommand = pm2Args[0] || "status";
+  const cmdArgs = ["compose", "exec", "app", "pm2", subCommand, ...pm2Args.slice(1)];
+  const code = await runCmd("docker", cmdArgs);
+  if (code !== 0) {
+    console.error(chalk.red("Error running PM2 command. Make sure the production stack is started."));
+    process.exit(1);
+  }
+}
+
 /**
  * Entry point for Blue Bird CLI Docker subcommands.
  */
@@ -286,6 +322,9 @@ async function main() {
     case "logs":
       await logsCommand(args[1], args[2]);
       break;
+    case "pm2":
+      await pm2Command(args.slice(1));
+      break;
     case "mysql":
     case "db": {
       let user, password, db, root = false;
@@ -312,7 +351,7 @@ async function main() {
     }
     default:
       console.log(chalk.yellow(`Unknown docker command: ${command}`));
-      console.log("Available commands: start, stop, build, ps, logs, mysql/db, df/disk, prune/clean");
+      console.log("Available commands: start, stop, build, ps, logs, pm2, mysql/db, df/disk, prune/clean");
   }
 }