@seip/blue-bird 1.1.3 → 1.1.5

package/core/cli/migrate.js

@@ -0,0 +1,342 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import chalk from "chalk";
+import { Database, DB_TYPE } from "../database.js";
+
+/**
+ * Generates current timestamp string in YYYYMMDD_HHMMSS format.
+ * @returns {string}
+ */
+function getTimestamp() {
+  const now = new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  const year = now.getFullYear();
+  const month = pad(now.getMonth() + 1);
+  const day = pad(now.getDate());
+  const hours = pad(now.getHours());
+  const mins = pad(now.getMinutes());
+  const secs = pad(now.getSeconds());
+  return `${year}${month}${day}_${hours}${mins}${secs}`;
+}
+
+/**
+ * Creates a new migration file in database/migrations/.
+ * @param {string} name
+ */
+function makeMigration(name) {
+  if (!name) {
+    console.log(chalk.red("[ERROR] Missing migration name."));
+    console.log("Usage: npx blue-bird make:migration <name>");
+    process.exit(1);
+  }
+
+  const cleanName = name.toLowerCase().replace(/[^a-z0-9_]/g, "_");
+  const filename = `${getTimestamp()}_${cleanName}.sql`;
+  const migrationsDir = path.resolve(process.cwd(), "database/migrations");
+
+  if (!fs.existsSync(migrationsDir)) {
+    fs.mkdirSync(migrationsDir, { recursive: true });
+  }
+
+  const filePath = path.join(migrationsDir, filename);
+
+  const template = `-- =============================================================
+-- Migration: ${cleanName}
+-- Created At: ${new Date().toISOString()}
+-- Driver Compatibility: SQLite / MySQL / PostgreSQL
+-- =============================================================
+
+CREATE TABLE IF NOT EXISTS ${cleanName} (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name VARCHAR(255) NOT NULL,
+  description TEXT,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+`;
+
+  fs.writeFileSync(filePath, template, "utf-8");
+  console.log(chalk.green(`[OK] Migration created: database/migrations/${filename}`));
+}
+
+/**
+ * Creates a new seed file in database/seeds/.
+ * @param {string} name
+ */
+function makeSeed(name) {
+  if (!name) {
+    console.log(chalk.red("[ERROR] Missing seed name."));
+    console.log("Usage: npx blue-bird make:seed <name>");
+    process.exit(1);
+  }
+
+  const cleanName = name.toLowerCase().replace(/[^a-z0-9_]/g, "_");
+  const filename = `${cleanName}.sql`;
+  const seedsDir = path.resolve(process.cwd(), "database/seeds");
+
+  if (!fs.existsSync(seedsDir)) {
+    fs.mkdirSync(seedsDir, { recursive: true });
+  }
+
+  const filePath = path.join(seedsDir, filename);
+
+  const template = `-- =============================================================
+-- Seed: ${cleanName}
+-- Created At: ${new Date().toISOString()}
+-- =============================================================
+
+-- INSERT INTO table_name (name) VALUES ('Sample Item 1');
+`;
+
+  fs.writeFileSync(filePath, template, "utf-8");
+  console.log(chalk.green(`[OK] Seed file created: database/seeds/${filename}`));
+}
+
+/**
+ * Ensures migrations tracking table exists.
+ * @param {Database} db
+ */
+async function ensureMigrationsTable(db) {
+  let ddl = "";
+  if (DB_TYPE === "postgres") {
+    ddl = `CREATE TABLE IF NOT EXISTS _bluebird_migrations (
+      id SERIAL PRIMARY KEY,
+      name VARCHAR(255) NOT NULL UNIQUE,
+      batch INT NOT NULL,
+      executed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    );`;
+  } else if (DB_TYPE === "mysql") {
+    ddl = `CREATE TABLE IF NOT EXISTS _bluebird_migrations (
+      id INT AUTO_INCREMENT PRIMARY KEY,
+      name VARCHAR(255) NOT NULL UNIQUE,
+      batch INT NOT NULL,
+      executed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    );`;
+  } else {
+    // sqlite default
+    ddl = `CREATE TABLE IF NOT EXISTS _bluebird_migrations (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL UNIQUE,
+      batch INTEGER NOT NULL,
+      executed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+    );`;
+  }
+
+  await db.query(ddl);
+}
+
+/**
+ * Executes pending database migrations.
+ */
+async function runMigrations() {
+  const migrationsDir = path.resolve(process.cwd(), "database/migrations");
+  if (!fs.existsSync(migrationsDir)) {
+    console.log(chalk.yellow("[INFO] No 'database/migrations' directory found. Nothing to migrate."));
+    return;
+  }
+
+  const files = fs
+    .readdirSync(migrationsDir)
+    .filter((f) => f.endsWith(".sql") || f.endsWith(".js"))
+    .sort();
+
+  if (files.length === 0) {
+    console.log(chalk.yellow("[INFO] No migration files found in 'database/migrations'."));
+    return;
+  }
+
+  let db;
+  try {
+    db = new Database(5);
+    await ensureMigrationsTable(db);
+  } catch (err) {
+    console.error(chalk.red("[ERROR] Could not connect to database to run migrations:"), err.message);
+    process.exit(1);
+  }
+
+  const appliedRows = (await db.query("SELECT name, batch FROM _bluebird_migrations ORDER BY id ASC")) || [];
+  const appliedSet = new Set(appliedRows.map((r) => r.name));
+
+  const maxBatchRow = await db.query("SELECT MAX(batch) as max_batch FROM _bluebird_migrations", [], "return_row");
+  const currentBatch = ((maxBatchRow && maxBatchRow.max_batch) || 0) + 1;
+
+  const pending = files.filter((f) => !appliedSet.has(f));
+
+  if (pending.length === 0) {
+    console.log(chalk.green("[INFO] Database is up to date. No pending migrations."));
+    process.exit(0);
+  }
+
+  console.log(chalk.cyan(`[INFO] Running ${pending.length} pending migration(s) (Batch #${currentBatch})...\n`));
+
+  for (const file of pending) {
+    const filePath = path.join(migrationsDir, file);
+    try {
+      if (file.endsWith(".sql")) {
+        const sql = fs.readFileSync(filePath, "utf-8");
+        // Split statements by semicolon where appropriate
+        const statements = sql
+          .split(/;\s*$/m)
+          .map((s) => s.trim())
+          .filter((s) => s.length > 0);
+
+        await db.transaction(async (tx) => {
+          for (const stmt of statements) {
+            await tx.query(stmt);
+          }
+          await tx.query(
+            "INSERT INTO _bluebird_migrations (name, batch) VALUES (?, ?)",
+            [file, currentBatch]
+          );
+        });
+      } else if (file.endsWith(".js")) {
+        const modulePath = `file://${filePath}`;
+        const migrationModule = await import(modulePath);
+        if (typeof migrationModule.up === "function") {
+          await db.transaction(async (tx) => {
+            await migrationModule.up(tx);
+            await tx.query(
+              "INSERT INTO _bluebird_migrations (name, batch) VALUES (?, ?)",
+              [file, currentBatch]
+            );
+          });
+        }
+      }
+
+      console.log(chalk.green(`  [MIGRATED] ${file}`));
+    } catch (err) {
+      console.error(chalk.red(`  [FAILED]   ${file}: ${err.message}`));
+      process.exit(1);
+    }
+  }
+
+  console.log(chalk.bold.green("\n[OK] All pending migrations executed successfully."));
+  process.exit(0);
+}
+
+/**
+ * Shows migration status list.
+ */
+async function showMigrationStatus() {
+  const migrationsDir = path.resolve(process.cwd(), "database/migrations");
+  if (!fs.existsSync(migrationsDir)) {
+    console.log(chalk.yellow("[INFO] No 'database/migrations' directory found."));
+    return;
+  }
+
+  const files = fs
+    .readdirSync(migrationsDir)
+    .filter((f) => f.endsWith(".sql") || f.endsWith(".js"))
+    .sort();
+
+  let db;
+  try {
+    db = new Database(5);
+    await ensureMigrationsTable(db);
+  } catch (err) {
+    console.error(chalk.red("[ERROR] Could not connect to database:"), err.message);
+    process.exit(1);
+  }
+
+  const appliedRows = (await db.query("SELECT name, batch, executed_at FROM _bluebird_migrations ORDER BY id ASC")) || [];
+  const appliedMap = new Map(appliedRows.map((r) => [r.name, r]));
+
+  console.log(chalk.bold.cyan("\n============================================================="));
+  console.log(chalk.bold.cyan(" Database Migrations Status"));
+  console.log(chalk.bold.cyan("=============================================================\n"));
+
+  for (const file of files) {
+    if (appliedMap.has(file)) {
+      const record = appliedMap.get(file);
+      console.log(`  ${chalk.green("[APPLIED]")}  ${file.padEnd(40)} (Batch: ${record.batch}, At: ${record.executed_at})`);
+    } else {
+      console.log(`  ${chalk.yellow("[PENDING]")}  ${file}`);
+    }
+  }
+
+  console.log("");
+  process.exit(0);
+}
+
+/**
+ * Runs seed scripts from database/seeds/.
+ */
+async function runSeeds() {
+  const seedsDir = path.resolve(process.cwd(), "database/seeds");
+  if (!fs.existsSync(seedsDir)) {
+    console.log(chalk.yellow("[INFO] No 'database/seeds' directory found. Nothing to seed."));
+    return;
+  }
+
+  const files = fs
+    .readdirSync(seedsDir)
+    .filter((f) => f.endsWith(".sql") || f.endsWith(".js"))
+    .sort();
+
+  if (files.length === 0) {
+    console.log(chalk.yellow("[INFO] No seed files found in 'database/seeds'."));
+    return;
+  }
+
+  let db;
+  try {
+    db = new Database(5);
+  } catch (err) {
+    console.error(chalk.red("[ERROR] Could not connect to database to run seeds:"), err.message);
+    process.exit(1);
+  }
+
+  console.log(chalk.cyan(`[INFO] Running ${files.length} seed file(s)...\n`));
+
+  for (const file of files) {
+    const filePath = path.join(seedsDir, file);
+    try {
+      if (file.endsWith(".sql")) {
+        const sql = fs.readFileSync(filePath, "utf-8");
+        const statements = sql
+          .split(/;\s*$/m)
+          .map((s) => s.trim())
+          .filter((s) => s.length > 0);
+
+        await db.transaction(async (tx) => {
+          for (const stmt of statements) {
+            await tx.query(stmt);
+          }
+        });
+      } else if (file.endsWith(".js")) {
+        const modulePath = `file://${filePath}`;
+        const seedModule = await import(modulePath);
+        if (typeof seedModule.seed === "function") {
+          await db.transaction(async (tx) => {
+            await seedModule.seed(tx);
+          });
+        }
+      }
+
+      console.log(chalk.green(`  [SEEDED] ${file}`));
+    } catch (err) {
+      console.error(chalk.red(`  [FAILED] ${file}: ${err.message}`));
+      process.exit(1);
+    }
+  }
+
+  console.log(chalk.bold.green("\n[OK] Database seeding completed."));
+  process.exit(0);
+}
+
+// CLI Dispatcher
+const rawArgs = process.argv.slice(2);
+const cmd = rawArgs[0];
+
+if (cmd === "make:migration") {
+  makeMigration(rawArgs[1]);
+} else if (cmd === "make:seed") {
+  makeSeed(rawArgs[1]);
+} else if (cmd === "migrate:status") {
+  showMigrationStatus();
+} else if (cmd === "seed") {
+  runSeeds();
+} else {
+  runMigrations();
+}

package/core/cli/nginx.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import chalk from "chalk";
+
+/**
+ * Parses .env file to extract APP_URL and PORT.
+ * @returns {{ domain: string, port: number, appUrl: string }}
+ */
+function getEnvConfig() {
+  const env = { ...process.env };
+  const envPath = path.resolve(process.cwd(), ".env");
+  if (fs.existsSync(envPath)) {
+    const content = fs.readFileSync(envPath, "utf-8");
+    content.split(/\r?\n/).forEach((line) => {
+      line = line.trim();
+      if (line && !line.startsWith("#") && line.includes("=")) {
+        const idx = line.indexOf("=");
+        const key = line.substring(0, idx).trim();
+        const value = line.substring(idx + 1).trim().replace(/^['"]|['"]$/g, "");
+        env[key] = value;
+      }
+    });
+  }
+
+  let domain = "";
+  if (env.APP_URL) {
+    try {
+      const parsedUrl = new URL(env.APP_URL.includes("://") ? env.APP_URL : `http://${env.APP_URL}`);
+      domain = parsedUrl.hostname;
+    } catch {
+      domain = env.APP_URL.replace(/^https?:\/\//, "").replace(/\/.*$/, "").replace(/:\d+$/, "").trim();
+    }
+  }
+
+  const port = parseInt(env.PORT || "3000", 10);
+  return { domain, port, appUrl: env.APP_URL || "" };
+}
+
+/**
+ * Generates Host Nginx reverse proxy configuration snippet.
+ */
+function generateNginxConfig() {
+  const rawArgs = process.argv.slice(2);
+  const filteredArgs = rawArgs.filter(
+    (a) => a !== "nginx:conf" && a !== "nginx:host" && a !== "nginx" && !a.endsWith("nginx.js") && !a.endsWith("init.js")
+  );
+
+  const envConfig = getEnvConfig();
+
+  let domainArg = filteredArgs.find((a) => !a.startsWith("-") && isNaN(Number(a)));
+  let portArg = filteredArgs.find((a) => !isNaN(Number(a)));
+
+  let domain = domainArg || envConfig.domain;
+  let port = portArg ? parseInt(portArg, 10) : envConfig.port;
+
+  if (!domain) {
+    domain = "example.com";
+    console.log(chalk.yellow("[INFO] No domain provided and APP_URL is not configured in .env. Defaulting to 'example.com'."));
+  } else if (!domainArg && envConfig.domain) {
+    console.log(chalk.cyan(`[INFO] Using domain '${domain}' and port ${port} resolved from .env (APP_URL / PORT).`));
+    console.log(chalk.gray(`       (You can override via: npx blue-bird nginx:conf <domain> [port])\n`));
+  }
+
+  // Clean domain name (strip protocol, path, port)
+  domain = domain.replace(/^https?:\/\//, "").replace(/\/.*$/, "").replace(/:\d+$/, "").trim();
+
+  const nginxSnippet = `# =============================================================
+# Blue Bird Host Nginx Reverse Proxy Configuration
+# File: /etc/nginx/sites-available/${domain}
+# =============================================================
+
+server {
+    listen 80;
+    listen [::]:80;
+    server_name ${domain};
+
+    # Maximum request body size for file uploads
+    client_max_body_size 50M;
+
+    # Security: Block hidden files and scan attempts
+    location ~* /\\.(env|git) {
+        deny all;
+        return 404;
+    }
+
+    # Reverse proxy to Blue Bird container stack
+    location / {
+        proxy_pass http://127.0.0.1:${port};
+        proxy_http_version 1.1;
+
+        # WebSocket upgrade support
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+
+        # Standard proxy headers
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_set_header X-Forwarded-Host $host;
+        proxy_set_header X-Forwarded-Port $server_port;
+
+        # Proxy timeouts
+        proxy_connect_timeout 60s;
+        proxy_send_timeout 60s;
+        proxy_read_timeout 60s;
+    }
+}`;
+
+  console.log(chalk.bold.cyan("============================================================="));
+  console.log(chalk.bold.cyan(` Host Nginx Configuration & Let's Encrypt Setup for: ${domain}`));
+  console.log(chalk.bold.cyan("============================================================="));
+  console.log("");
+  console.log(chalk.yellow("1. Create the site configuration file on your VPS:"));
+  console.log(chalk.green(`   sudo nano /etc/nginx/sites-available/${domain}`));
+  console.log("");
+  console.log(chalk.yellow("2. Paste the following configuration block:"));
+  console.log("");
+  console.log(chalk.white(nginxSnippet));
+  console.log("");
+  console.log(chalk.yellow("3. Enable the site configuration:"));
+  console.log(chalk.green(`   sudo ln -s /etc/nginx/sites-available/${domain} /etc/nginx/sites-enabled/`));
+  console.log("");
+  console.log(chalk.yellow("4. Test Nginx syntax:"));
+  console.log(chalk.green("   sudo nginx -t"));
+  console.log("");
+  console.log(chalk.yellow("5. Reload Nginx to apply changes:"));
+  console.log(chalk.green("   sudo systemctl reload nginx"));
+  console.log("");
+  console.log(chalk.yellow("6. Provision free SSL certificate with Certbot (Let's Encrypt):"));
+  console.log(chalk.green(`   sudo certbot --nginx -d ${domain}`));
+  console.log("");
+  console.log(chalk.bold.cyan("============================================================="));
+}
+
+generateNginxConfig();

package/core/cli/route.js

@@ -1,43 +1,144 @@
-import path from 'path';
-import fs from 'fs';
-import Config from "../config.js";
+#!/usr/bin/env node
 
-const __dirname = Config.dirname();
+import path from "node:path";
+import fs from "node:fs";
+import chalk from "chalk";
 
 class RouteCLI {
   /**
-   * Create route 
+   * Creates a new RESTful route file with Validation, Cache, and optional Auth.
    */
-    create() {
-        let nameRoute = process.argv[2];
-        if (!nameRoute) {
-            console.log("Please provide a route name. Usage: npm run route <route-name>");
-            return;
-        }
-        nameRoute =nameRoute.charAt(0).toUpperCase() + nameRoute.slice(1);
-        const folder= path.join(__dirname, 'backend/routes');
-        if (!fs.existsSync(folder)){
-            fs.mkdirSync(folder, { recursive: true });
-        }
-        const filePath = path.join(folder, `${nameRoute}.js`);
-        if (fs.existsSync(filePath)) {
-            console.log(`Route ${nameRoute} already exists.`);
-            return;
-        }
-        const content =`import Router from "@seip/blue-bird/core/router.js" 
-
-const router${nameRoute} = new Router("/${nameRoute.toLowerCase()}");
-
-router${nameRoute}.get("/", (req, res) => {
-    res.json({ message: "Hello from ${nameRoute} route!" });
-});
+  create() {
+    const rawArgs = process.argv.slice(2);
+    // Filter out command name if invoked as 'route' or 'make:route'
+    const args = rawArgs.filter(
+      (a) => a !== "route" && a !== "make:route" && !a.endsWith("route.js")
+    );
+
+    let routeName = args.find((a) => !a.startsWith("-"));
+    const withAuth = args.some((a) => a === "--auth" || a === "-a");
+
+    if (!routeName) {
+      console.log(chalk.red("[ERROR] Missing route name."));
+      console.log("");
+      console.log("Usage:");
+      console.log("  npx blue-bird make:route <name> [--auth]");
+      console.log("");
+      console.log("Examples:");
+      console.log("  npx blue-bird make:route products");
+      console.log("  npx blue-bird make:route articles --auth");
+      process.exit(1);
+    }
 
-export default router${nameRoute};
-        `;
-        fs.writeFileSync(filePath, content);
-        console.log(`Route ${nameRoute} created successfully at ${filePath}`);
+    // Normalize casing
+    routeName = routeName.toLowerCase().replace(/[^a-z0-9_-]/g, "");
+    const singularName = routeName.endsWith("s") ? routeName.slice(0, -1) : routeName;
+    const pascalName = routeName.charAt(0).toUpperCase() + routeName.slice(1);
+    const routerVarName = `router${pascalName}`;
+    const basePath = `/${routeName}`;
+
+    const routesFolder = path.resolve(process.cwd(), "backend/routes");
+    if (!fs.existsSync(routesFolder)) {
+      fs.mkdirSync(routesFolder, { recursive: true });
+    }
+
+    const filePath = path.join(routesFolder, `${routeName}.js`);
+    if (fs.existsSync(filePath)) {
+      console.log(chalk.yellow(`[WARN] Route file '${routeName}.js' already exists at backend/routes/${routeName}.js.`));
+      return;
     }
+
+    const authImport = withAuth
+      ? `import Auth from "@seip/blue-bird/core/auth.js";\n`
+      : "";
+
+    const authProtect = withAuth ? `Auth.protect(), ` : "";
+
+    const content = `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";
+${authImport}
+const ${routerVarName} = new Router("${basePath}");
+
+// Validation schema for incoming requests
+const ${singularName}Schema = {
+  name: { required: true, min: 2, max: 255 },
+  description: { required: false },
+  price: { required: false }
+};
+
+const validate${pascalName} = new Validator(${singularName}Schema, "en");
+
+/**
+ * GET ${basePath}
+ * List all items with in-memory / Redis route caching (60 seconds)
+ */
+${routerVarName}.get("/", Cache.middleware(60), (req, res) => {
+  res.ok({ ${routeName}: [] }, "${pascalName} list retrieved successfully");
+});
+
+/**
+ * GET ${basePath}/:id
+ * Retrieve a single item by ID
+ */
+${routerVarName}.get("/:id", Cache.middleware(60), (req, res) => {
+  const { id } = req.params;
+  res.ok({ ${singularName}: { id } }, "${pascalName} retrieved successfully");
+});
+
+/**
+ * POST ${basePath}
+ * Create a new item (with validation and automatic cache invalidation)
+ */
+${routerVarName}.post("/", ${authProtect}validate${pascalName}.middleware(), async (req, res) => {
+  const data = req.body;
+
+  // Invalidate cached route list
+  await Cache.delete("${basePath}");
+
+  res.created({ ${singularName}: data }, "${pascalName} created successfully");
+});
+
+/**
+ * PUT ${basePath}/:id
+ * Update an existing item
+ */
+${routerVarName}.put("/:id", ${authProtect}validate${pascalName}.middleware(), async (req, res) => {
+  const { id } = req.params;
+  const data = req.body;
+
+  // Invalidate cached item and list
+  await Cache.delete("${basePath}");
+  await Cache.delete(\`${basePath}/\${id}\`);
+
+  res.ok({ ${singularName}: { id, ...data } }, "${pascalName} updated successfully");
+});
+
+/**
+ * DELETE ${basePath}/:id
+ * Delete an existing item
+ */
+${routerVarName}.delete("/:id", ${authProtect}async (req, res) => {
+  const { id } = req.params;
+
+  // Invalidate cache
+  await Cache.delete("${basePath}");
+  await Cache.delete(\`${basePath}/\${id}\`);
+
+  res.ok({ id }, "${pascalName} deleted successfully");
+});
+
+export default ${routerVarName};
+`;
+
+    fs.writeFileSync(filePath, content, "utf-8");
+    console.log(chalk.green(`[OK] Route '${routeName}' created successfully at backend/routes/${routeName}.js`));
+    console.log("");
+    console.log(chalk.cyan("To register this route, import it in backend/index.js:"));
+    console.log(chalk.gray(`  import ${routerVarName} from "./routes/${routeName}.js";`));
+    console.log(chalk.gray(`  // Pass ${routerVarName} into App({ routes: [...] })`));
+  }
 }
 
 const routeCLI = new RouteCLI();
-routeCLI.create()
+routeCLI.create();

package/core/cli/swagger.js

@@ -1,3 +1,5 @@
+#!/usr/bin/env node
+
 import { execSync } from "node:child_process";
 
 class SwaggerCli {