@seip/blue-bird 0.6.4 → 0.7.0

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/cli/init.js

@@ -3,6 +3,10 @@
 import fs from "node:fs";
 import path from "node:path";
 import chalk from "chalk";
+import readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import crypto from "node:crypto";
+import { execSync } from "node:child_process";
 
 /**
  * Initializes a new Blue Bird project by copying the base structure.
@@ -19,13 +23,63 @@ class ProjectInit {
     async run() {
         console.log(chalk.cyan("Starting Blue Bird project initialization..."));
 
+        const rl = readline.createInterface({ input, output });
+
+        let title = "Blue-Bird";
+        let port = 3000;
+        let appUrl = "http://localhost:3000";
+        let useMysql = false;
+        let dbName = "blue_bird";
+        let dbUser = "root";
+        let dbPassword = "root";
+        let dbPort = 3306;
+
+        try {
+            const ask = async (query, defaultValue) => {
+                const formattedQuery = defaultValue !== undefined ? `${query} [${defaultValue}]: ` : `${query}: `;
+                const answer = await rl.question(formattedQuery);
+                return answer.trim() || defaultValue;
+            };
+
+            title = await ask("Project Title", title);
+            const portInput = await ask("Server Port", port);
+            port = parseInt(portInput, 10);
+            if (Number.isNaN(port)) {
+                port = 3000;
+            }
+
+            const defaultAppUrl = `http://localhost:${port}`;
+            appUrl = await ask("Application URL", defaultAppUrl);
+
+            const mysqlAns = await ask("Do you want to configure MySQL? (y/n)", "n");
+            useMysql = mysqlAns.toLowerCase() === "y" || mysqlAns.toLowerCase() === "yes";
+
+            if (useMysql) {
+                dbName = await ask("Database Name", dbName);
+                dbUser = await ask("Database User", dbUser);
+                dbPassword = await ask("Database Password", dbPassword);
+                const dbPortInput = await ask("Database Port", dbPort);
+                dbPort = parseInt(dbPortInput, 10);
+                if (Number.isNaN(dbPort)) {
+                    dbPort = 3306;
+                }
+            }
+        } catch (error) {
+            console.error(chalk.red("[ERROR] Error reading configuration input:"), error.message);
+            rl.close();
+            return;
+        } finally {
+            rl.close();
+        }
+
         const itemsToCopy = [
             "backend",
             "frontend",
             "docker",
             "docker-compose.yml",
             ".env_example",
-            "AGENTS.md"
+            "AGENTS.md",
+            "index.js"
         ];
 
         try {
@@ -36,31 +90,78 @@ class ProjectInit {
                 if (fs.existsSync(src)) {
                     if (!fs.existsSync(dest)) {
                         this.copyRecursive(src, dest);
-                        console.log(chalk.green(`✓ Copied ${item} to root.`));
+                        console.log(chalk.green(`[OK] Copied ${item} to root.`));
                     } else {
-                        console.log(chalk.yellow(`! ${item} already exists, skipping.`));
+                        console.log(chalk.yellow(`[SKIP] ${item} already exists, skipping.`));
                     }
                 } else {
-                    console.warn(chalk.red(`✗ Source ${item} not found in ${this.sourceDir}`));
+                    console.warn(chalk.red(`[ERROR] Source ${item} not found in ${this.sourceDir}`));
                 }
             });
 
             const envPath = path.join(this.appDir, ".env");
             const envExamplePath = path.join(this.appDir, ".env_example");
-            if (fs.existsSync(envExamplePath) && !fs.existsSync(envPath)) {
-                fs.copyFileSync(envExamplePath, envPath);
-                console.log(chalk.green("✓ Created .env from .env_example."));
+
+            if (fs.existsSync(envExamplePath)) {
+                let envContent = fs.readFileSync(envExamplePath, "utf-8");
+
+                const jwtSecret = crypto.randomBytes(32).toString("hex");
+
+                const updates = {
+                    TITLE: title,
+                    PORT: port,
+                    APP_URL: appUrl,
+                    JWT_SECRET: jwtSecret,
+                };
+
+                if (useMysql) {
+                    updates.DB_NAME = dbName;
+                    updates.DB_USER = dbUser;
+                    updates.DB_PASSWORD = dbPassword;
+                    updates.DB_PORT = dbPort;
+                    updates.DATABASE_URL = `mysql://${dbUser}:${dbPassword}@localhost:${dbPort}/${dbName}`;
+                }
+
+                const lines = envContent.split(/\r?\n/);
+                const updatedLines = lines.map(line => {
+                    const match = line.match(/^([A-Z_]+)=(.+)/);
+                    if (match) {
+                        const key = match[1];
+                        if (updates[key] !== undefined) {
+                            const value = updates[key];
+                            if (typeof value === "string" && !value.startsWith('"')) {
+                                return `${key}="${value}"`;
+                            }
+                            return `${key}=${value}`;
+                        }
+                    }
+                    return line;
+                });
+                envContent = updatedLines.join("\n");
+
+                fs.writeFileSync(envPath, envContent, "utf-8");
+                console.log(chalk.green("[OK] Created and configured .env file."));
             }
 
             this.updatePackageJson();
 
+            if (useMysql) {
+                console.log(chalk.cyan("[INFO] Installing mysql2 and redis packages..."));
+                try {
+                    execSync("npm install mysql2 redis", { stdio: "inherit", cwd: this.appDir });
+                    console.log(chalk.green("[OK] Successfully installed mysql2 and redis."));
+                } catch (error) {
+                    console.warn(chalk.yellow("[ERROR] Automatic package installation failed. Please run 'npm install mysql2 redis' manually."));
+                }
+            }
+
             console.log(chalk.blue("\nBlue Bird initialization completed!"));
             console.log(chalk.white("Next steps:"));
             console.log(chalk.bold("  npm install"));
             console.log(chalk.bold("  npm run dev"));
 
         } catch (error) {
-            console.error(chalk.red("Error during initialization:"), error.message);
+            console.error(chalk.red("[ERROR] Error during initialization:"), error.message);
         }
     }
 
@@ -74,8 +175,11 @@ class ProjectInit {
             pkg.scripts = pkg.scripts || {};
 
             const scriptsToAdd = {
-                "dev": "node --watch --env-file=.env backend/index.js",
-                "start": "node --env-file=.env backend/index.js",
+                "dev": "node --watch --env-file=.env index.js",
+                "dev:astro": "astro dev --root frontend",
+                "dev:api": "node --watch --env-file=.env index.js",
+                "start": "node --env-file=.env index.js",
+                "build": "astro build --root frontend",
                 "init": "blue-bird",
                 "route": "blue-bird route",
                 "swagger-install": "blue-bird swagger-install",
@@ -90,9 +194,14 @@ class ProjectInit {
                 }
             }
 
+            if (pkg.type !== "module") {
+                pkg.type = "module";
+                updated = true;
+            }
+
             if (updated) {
                 fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
-                console.log(chalk.green("✓ Updated package.json scripts."));
+                console.log(chalk.green("[OK] Updated package.json configuration."));
             }
         }
     }

package/core/logger.js

@@ -1,100 +1,99 @@
 import fs from "node:fs";
 import path from "node:path";
-import Config from "./config.js"
+import Config from "./config.js";
 
-const __dirname = Config.dirname()
+const __dirname = Config.dirname();
 
 /**
  * Logger class for managing application logs by creating dated folders and log files.
  */
 class Logger {
-
-    /**
-     * Initializes the Logger instance and ensures the logs directory exists.
-     */
-    constructor() {
-        this.folder = path.join(__dirname, "logs");
-        this._currentDay = null;
-        this._currentDayFolder = null;
-        if (!fs.existsSync(this.folder)) {
-            fs.mkdirSync(this.folder, { recursive: true });
-        }
+  /**
+   * Initializes the Logger instance and ensures the logs directory exists.
+   */
+  constructor() {
+    this.folder = path.join(__dirname, "backend", "logs");
+    this._currentDay = null;
+    this._currentDayFolder = null;
+    if (!fs.existsSync(this.folder)) {
+      fs.mkdirSync(this.folder, { recursive: true });
     }
+  }
 
-    /**
-     * Ensures and returns the path to the log folder for the current day.
-     * Caches the folder path for the current day to avoid repeated fs checks.
-     * @returns {string} The absolute path to the current day's log folder.
-     */
-    nowFolder() {
-        const today = this.now();
-
-        if (this._currentDay === today && this._currentDayFolder) {
-            return this._currentDayFolder;
-        }
+  /**
+   * Ensures and returns the path to the log folder for the current day.
+   * Caches the folder path for the current day to avoid repeated fs checks.
+   * @returns {string} The absolute path to the current day's log folder.
+   */
+  nowFolder() {
+    const today = this.now();
 
-        const folder = path.join(this.folder, today);
+    if (this._currentDay === today && this._currentDayFolder) {
+      return this._currentDayFolder;
+    }
 
-        if (!fs.existsSync(folder)) {
-            fs.mkdirSync(folder, { recursive: true });
-        }
+    const folder = path.join(this.folder, today);
 
-        this._currentDay = today;
-        this._currentDayFolder = folder;
-        return folder;
+    if (!fs.existsSync(folder)) {
+      fs.mkdirSync(folder, { recursive: true });
     }
 
-    /**
-     * Gets the current date formatted as YYYY-MM-DD.
-     * @returns {string} The formatted date string.
-     */
-    now() {
-        return new Date().toISOString().split("T")[0];
-    }
+    this._currentDay = today;
+    this._currentDayFolder = folder;
+    return folder;
+  }
 
-    /**
-     * Appends an informational message to the info.log file (non-blocking).
-     * @param {string} message - The message to log.
-     */
-    info(message) {
-        const logFile = path.join(this.nowFolder(), 'info.log');
-        fs.appendFile(logFile, `${message}\n`, (err) => {
-            if (err) console.error('Logger write error:', err.message);
-        });
-    }
+  /**
+   * Gets the current date formatted as YYYY-MM-DD.
+   * @returns {string} The formatted date string.
+   */
+  now() {
+    return new Date().toISOString().split("T")[0];
+  }
 
-    /**
-     * Appends an error message to the error.log file (non-blocking).
-     * @param {string} message - The error message to log.
-     */
-    error(message) {
-        const logFile = path.join(this.nowFolder(), 'error.log');
-        fs.appendFile(logFile, `${message}\n`, (err) => {
-            if (err) console.error('Logger write error:', err.message);
-        });
-    }
+  /**
+   * Appends an informational message to the info.log file (non-blocking).
+   * @param {string} message - The message to log.
+   */
+  info(message) {
+    const logFile = path.join(this.nowFolder(), "info.log");
+    fs.appendFile(logFile, `${message}\n`, (err) => {
+      if (err) console.error("Logger write error:", err.message);
+    });
+  }
 
-    /**
-     * Appends a warning message to the warn.log file (non-blocking).
-     * @param {string} message - The warning message to log.
-     */
-    warning(message) {
-        const logFile = path.join(this.nowFolder(), 'warn.log');
-        fs.appendFile(logFile, `${message}\n`, (err) => {
-            if (err) console.error('Logger write error:', err.message);
-        });
-    }
+  /**
+   * Appends an error message to the error.log file (non-blocking).
+   * @param {string} message - The error message to log.
+   */
+  error(message) {
+    const logFile = path.join(this.nowFolder(), "error.log");
+    fs.appendFile(logFile, `${message}\n`, (err) => {
+      if (err) console.error("Logger write error:", err.message);
+    });
+  }
 
-    /**
-     * Appends a debug message to the debug.log file (non-blocking).
-     * @param {string} message - The debug message to log.
-     */
-    debug(message) {
-        const logFile = path.join(this.nowFolder(), 'debug.log');
-        fs.appendFile(logFile, `${message}\n`, (err) => {
-            if (err) console.error('Logger write error:', err.message);
-        });
-    }
+  /**
+   * Appends a warning message to the warn.log file (non-blocking).
+   * @param {string} message - The warning message to log.
+   */
+  warning(message) {
+    const logFile = path.join(this.nowFolder(), "warn.log");
+    fs.appendFile(logFile, `${message}\n`, (err) => {
+      if (err) console.error("Logger write error:", err.message);
+    });
+  }
+
+  /**
+   * Appends a debug message to the debug.log file (non-blocking).
+   * @param {string} message - The debug message to log.
+   */
+  debug(message) {
+    const logFile = path.join(this.nowFolder(), "debug.log");
+    fs.appendFile(logFile, `${message}\n`, (err) => {
+      if (err) console.error("Logger write error:", err.message);
+    });
+  }
 }
 
 export default Logger;

package/core/router.js

@@ -1,6 +1,6 @@
 import express from "express";
 import Config from "./config.js";
-import SEO from "./seo.js";
+
 
 const props = Config.props();
 
@@ -57,11 +57,7 @@ class Router {
     if (path === "/*" || path === "*") {
       path = /.*/;
     }
-    if (this._seo && typeof path === "string") {
-      const fullPath = this.path === "/" ? path : `${this.path}${path}`;
-      const normalizedPath = fullPath === "//" ? "/" : fullPath.replace(/\/+/g, "/");
-      SEO.addRoute(normalizedPath, this._languages);
-    }
+
     this.router.get(path, callback);
   }
 

package/frontend/astro.config.mjs

@@ -0,0 +1,35 @@
+import { defineConfig } from 'astro/config';
+import node from '@astrojs/node';
+import { loadEnv } from 'vite';
+import { fileURLToPath } from 'url';
+import { dirname, resolve } from 'path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const env = loadEnv(
+  process.env.NODE_ENV ?? 'development',
+  resolve(__dirname, '..'),
+  '',
+);
+
+const apiPort = env.PORT || '3000';
+const apiHost = (env.HOST || 'localhost').replace(/^["']|["']$/g, '');
+const apiTarget = `http://${apiHost}:${apiPort}`;
+
+export default defineConfig({
+  output: 'server',
+  adapter: node({
+    mode: 'middleware',
+  }),
+  vite: {
+    envDir: resolve(__dirname, '..'),
+    server: {
+      proxy: {
+        '/api': {
+          target: apiTarget,
+          changeOrigin: true,
+        },
+      },
+    },
+  },
+});