@seip/blue-bird 1.0.2 → 1.1.1

package/core/cli/init.js

@@ -28,8 +28,9 @@ class ProjectInit {
     let title = "Blue-Bird";
     let port = 3000;
     let appUrl = "http://localhost:3000";
-    let dbType = "none";
+    let dbType = "sqlite";
     let dbName = "blue_bird";
+    let dbFile = "database/blue_bird.db";
     let dbUser = "root";
     let dbPassword = "root";
     let dbPort = 3306;
@@ -55,11 +56,17 @@ class ProjectInit {
       appUrl = await ask("Application URL", defaultAppUrl);
 
       const dbTypeAns = await ask(
-        "Which database do you want to configure? (none / mysql / postgres)",
-        "none",
+        "Which database do you want to configure? (sqlite / mysql / postgres / none)",
+        "sqlite",
       );
       const cleanDbTypeAns = dbTypeAns.toLowerCase().trim();
       if (
+        cleanDbTypeAns === "sqlite" ||
+        cleanDbTypeAns === "sql" ||
+        cleanDbTypeAns === "sqlite3"
+      ) {
+        dbType = "sqlite";
+      } else if (
         cleanDbTypeAns === "postgres" ||
         cleanDbTypeAns === "postgresql" ||
         cleanDbTypeAns === "pg" ||
@@ -72,7 +79,15 @@ class ProjectInit {
         dbType = "none";
       }
 
-      if (dbType !== "none") {
+      if (dbType === "sqlite") {
+        dbName = await ask("Database Name", dbName);
+        const defaultDbFile = `database/${dbName}.db`;
+        dbFile = await ask("Database File Path", defaultDbFile);
+        const dbDir = path.dirname(path.join(this.appDir, dbFile));
+        if (!fs.existsSync(dbDir)) {
+          fs.mkdirSync(dbDir, { recursive: true });
+        }
+      } else if (dbType !== "none") {
         dbName = await ask("Database Name", dbName);
         dbUser = await ask(
           "Database User",
@@ -103,8 +118,6 @@ class ProjectInit {
       "docker",
       ".env_example",
       "AGENTS.md",
-      "index.js",
-      ".gitignore"
     ];
 
     try {
@@ -128,12 +141,32 @@ class ProjectInit {
         }
       });
 
+      const gitignoreContent = `node_modules\nlogs\n.env\npackage-lock.json\n*.db\n*.sqlite\n*.sqlite-wal\n*.sqlite-shm\n*.db-wal\n*.db-shm\ntest/\n\nbackups/*.sql\nbackups/*.db\n`;
+      const gitignoreDest = path.join(this.appDir, ".gitignore");
+      const gitignoreSrc = path.join(this.sourceDir, ".gitignore");
+
+      if (!fs.existsSync(gitignoreDest)) {
+        if (fs.existsSync(gitignoreSrc)) {
+          fs.copyFileSync(gitignoreSrc, gitignoreDest);
+          console.log(chalk.green("[OK] Copied .gitignore to root."));
+        } else {
+          fs.writeFileSync(gitignoreDest, gitignoreContent, "utf-8");
+          console.log(chalk.green("[OK] Created .gitignore file."));
+        }
+      } else {
+        console.log(
+          chalk.yellow("[SKIP] .gitignore already exists, skipping."),
+        );
+      }
+
       const composeTemplateName =
         dbType === "postgres"
           ? "docker-compose.postgres.yml"
           : dbType === "mysql"
             ? "docker-compose.mysql.yml"
-            : "docker-compose.none.yml";
+            : dbType === "sqlite"
+              ? "docker-compose.sqlite.yml"
+              : "docker-compose.none.yml";
       const composeSrc = path.join(
         this.sourceDir,
         "docker",
@@ -166,8 +199,15 @@ class ProjectInit {
         let envContent = fs.readFileSync(envExamplePath, "utf-8");
 
         const jwtSecret = crypto.randomBytes(32).toString("hex");
+        const composeProjectName =
+          title
+            .toLowerCase()
+            .trim()
+            .replace(/\s+/g, "-")
+            .replace(/[^a-z0-9_-]/g, "") || "blue-bird";
 
         const updates = {
+          COMPOSE_PROJECT_NAME: composeProjectName,
           TITLE: title,
           PORT: port,
           APP_URL: appUrl,
@@ -175,13 +215,19 @@ class ProjectInit {
           DB_TYPE: dbType,
         };
 
-        if (dbType === "mysql") {
+        if (dbType === "sqlite") {
+          updates.DB_TYPE = "sqlite";
+          updates.DB_FILE = dbFile;
+          updates.DATABASE_URL = `sqlite:${dbFile}`;
+        } else if (dbType === "mysql") {
+          updates.DB_TYPE = "mysql";
           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}`;
         } else if (dbType === "postgres") {
+          updates.DB_TYPE = "postgres";
           updates.DB_NAME = dbName;
           updates.DB_USER = dbUser;
           updates.DB_PASSWORD = dbPassword;
@@ -190,10 +236,14 @@ class ProjectInit {
         }
 
         const lines = envContent.split(/\r?\n/);
+        let foundComposeProjectName = false;
         const updatedLines = lines.map((line) => {
           const match = line.match(/^([A-Z_]+)=(.+)/);
           if (match) {
             const key = match[1];
+            if (key === "COMPOSE_PROJECT_NAME") {
+              foundComposeProjectName = true;
+            }
             if (updates[key] !== undefined) {
               const value = updates[key];
               if (typeof value === "string" && !value.startsWith('"')) {
@@ -204,6 +254,21 @@ class ProjectInit {
           }
           return line;
         });
+
+        if (!foundComposeProjectName && updates.COMPOSE_PROJECT_NAME) {
+          const titleIdx = updatedLines.findIndex((l) => l.startsWith("TITLE="));
+          if (titleIdx !== -1) {
+            updatedLines.splice(
+              titleIdx,
+              0,
+              `COMPOSE_PROJECT_NAME="${updates.COMPOSE_PROJECT_NAME}"`,
+            );
+          } else {
+            updatedLines.push(
+              `COMPOSE_PROJECT_NAME="${updates.COMPOSE_PROJECT_NAME}"`,
+            );
+          }
+        }
         envContent = updatedLines.join("\n");
 
         fs.writeFileSync(envPath, envContent, "utf-8");
@@ -218,7 +283,9 @@ class ProjectInit {
         );
         try {
           let packagesToInstall = ["redis"];
-          if (dbType === "postgres") {
+          if (dbType === "sqlite") {
+            packagesToInstall.push("better-sqlite3");
+          } else if (dbType === "postgres") {
             packagesToInstall.push("pg");
           } else {
             packagesToInstall.push("mysql2");
@@ -323,6 +390,63 @@ class ProjectInit {
   }
 }
 
+/**
+ * Handles adding on-demand modules and dependencies.
+ * @param {string} [feature]
+ */
+function addCommand(feature) {
+  if (!feature) {
+    console.log(chalk.yellow("Usage: npx blue-bird add <feature>"));
+    console.log("Available features to add:");
+    console.log("  upload | multer     - Installs multer for file uploads");
+    console.log("  ws | websocket      - Installs ws for WebSockets");
+    console.log("  redis               - Installs redis for distributed caching and sessions");
+    console.log("  sqlite              - Installs better-sqlite3 for local SQLite database");
+    console.log("  mysql               - Installs mysql2 for MySQL database");
+    console.log("  postgres | pg       - Installs pg for PostgreSQL database");
+    console.log("  bcrypt              - Installs bcrypt for password hashing");
+    console.log("  swagger             - Installs swagger-ui-express");
+    return;
+  }
+
+  const cleanFeature = feature.toLowerCase().trim();
+  const packageMap = {
+    upload: "multer",
+    multer: "multer",
+    ws: "ws",
+    websocket: "ws",
+    websockets: "ws",
+    redis: "redis",
+    sqlite: "better-sqlite3",
+    "better-sqlite3": "better-sqlite3",
+    mysql: "mysql2",
+    mysql2: "mysql2",
+    postgres: "pg",
+    postgresql: "pg",
+    pg: "pg",
+    bcrypt: "bcrypt",
+    swagger: "swagger-ui-express",
+  };
+
+  const pkgName = packageMap[cleanFeature];
+  if (!pkgName) {
+    console.error(chalk.red(`[ERROR] Unknown feature '${feature}'.`));
+    console.log("Available features: upload, ws, redis, sqlite, mysql, postgres, bcrypt, swagger");
+    return;
+  }
+
+  console.log(chalk.cyan(`[INFO] Installing ${pkgName}...`));
+  try {
+    execSync(`npm install ${pkgName}`, {
+      stdio: "inherit",
+      cwd: process.cwd(),
+    });
+    console.log(chalk.green(`[OK] Successfully installed ${pkgName}.`));
+  } catch (err) {
+    console.error(chalk.red(`[ERROR] Failed to install ${pkgName}:`), err.message);
+  }
+}
+
 const initializer = new ProjectInit();
 
 const args = process.argv.slice(2);
@@ -331,4 +455,6 @@ const command = args[0];
 if (command === "route") import("./route.js");
 else if (command === "swagger-install") import("./swagger.js");
 else if (command === "docker") import("./docker.js");
+else if (command === "add") addCommand(args[1]);
 else initializer.run();
+

package/core/database.js

@@ -1,3 +1,5 @@
+import fs from "node:fs";
+import path from "node:path";
 import crypto from "node:crypto";
 import { getRedisClient } from "./cache.js";
 
@@ -15,14 +17,20 @@ if (
     DB_TYPE = "postgres";
   } else if (process.env.DATABASE_URL.startsWith("mysql://")) {
     DB_TYPE = "mysql";
+  } else if (
+    process.env.DATABASE_URL.startsWith("sqlite://") ||
+    process.env.DATABASE_URL.startsWith("sqlite:")
+  ) {
+    DB_TYPE = "sqlite";
   }
 }
 if (!DB_TYPE) {
-  DB_TYPE = "mysql";
+  DB_TYPE = "sqlite";
 }
 
 let mysqlPromise = null;
 let pgPromise = null;
+let sqlitePromise = null;
 
 if (DB_TYPE === "postgres") {
   try {
@@ -40,23 +48,79 @@ if (DB_TYPE === "postgres") {
       "[DATABASE ERROR] mysql2 package is not installed. Database wrapper is disabled.",
     );
   }
+} else if (DB_TYPE === "sqlite") {
+  try {
+    sqlitePromise = await import("better-sqlite3");
+  } catch (err) {
+    console.error(
+      "[DATABASE ERROR] better-sqlite3 package is not installed. Database wrapper is disabled.",
+    );
+  }
 }
 
 /**
- * Database class wrapping mysql2 and pg with reconnection retries, connection pooling, and query caching.
+ * Database class wrapping better-sqlite3, mysql2, and pg with reconnection retries, connection pooling, and query caching.
  */
 class Database {
   /**
    * Initializes config from DATABASE_URL or DB_* environment variables.
-   * For default Database use .env DB_HOST, DB_USER, DB_PASSWORD...
-   * @param {number} [connectionLimit=10] - Maximum number of connections in the pool.
-   * @param {number} [queueLimit=0] - Maximum number of queued connections.
-   * @param {Object} [config={}] - Additional configuration options: DB_HOST, DB_USER, DB_PASSWORD, DB_NAME, DB_PORT, DB_TYPE.
+   * For default Database use .env DB_HOST, DB_USER, DB_PASSWORD... or DB_FILE for SQLite.
+   * @param {number} [connectionLimit=10] - Maximum number of connections in the pool (MySQL/Postgres).
+   * @param {number} [queueLimit=0] - Maximum number of queued connections (MySQL/Postgres).
+   * @param {Object} [config={}] - Additional configuration options: DB_FILE, DB_HOST, DB_USER, DB_PASSWORD, DB_NAME, DB_PORT, DB_TYPE.
+   * @example const connection = new Database(10, 0, { DB_TYPE: "sqlite", DB_FILE: "database/blue_bird.db" });
    * @example const connection = new Database(10, 0, { DB_HOST: "localhost", DB_USER: "root", DB_PASSWORD: "password", DB_NAME: "blue_bird", DB_PORT: 3306, DB_TYPE: "mysql" });
    */
   constructor(connectionLimit = 10, queueLimit = 0, config = {}) {
     this.pool = null;
-    this.type = DB_TYPE;
+    this.db = null;
+    this.type = config.DB_TYPE || DB_TYPE;
+
+    let defaultSqliteFile = process.env.DB_FILE || "database/blue_bird.db";
+    let busyTimeout = 5000;
+    let journalMode = "WAL";
+    let synchronous = "NORMAL";
+
+    if (process.env.DATABASE_URL && !process.env.DATABASE_URL.startsWith("#")) {
+      try {
+        if (
+          process.env.DATABASE_URL.startsWith("sqlite://") ||
+          process.env.DATABASE_URL.startsWith("sqlite:")
+        ) {
+          const rawUrl = process.env.DATABASE_URL;
+          const cleanUrl = rawUrl.replace(/^sqlite:\/\/|^sqlite:/, "");
+          const [filePath, queryStr] = cleanUrl.split("?");
+          if (filePath) {
+            defaultSqliteFile = filePath;
+          }
+          if (queryStr) {
+            const params = new URLSearchParams(queryStr);
+            if (params.has("busy_timeout")) {
+              busyTimeout =
+                parseInt(params.get("busy_timeout"), 10) || busyTimeout;
+            }
+            if (params.has("journal_mode")) {
+              journalMode = params.get("journal_mode").toUpperCase();
+            }
+            if (params.has("synchronous")) {
+              synchronous = params.get("synchronous").toUpperCase();
+            }
+          }
+        }
+      } catch (err) {
+        console.error(
+          "[DATABASE ERROR] Failed to parse SQLite DATABASE_URL:",
+          err.message,
+        );
+      }
+    }
+
+    this.sqliteConfig = {
+      filename: config.DB_FILE || defaultSqliteFile,
+      busyTimeout: config.busyTimeout || busyTimeout,
+      journalMode: config.journalMode || journalMode,
+      synchronous: config.synchronous || synchronous,
+    };
 
     this.config = {
       ...config,
@@ -101,13 +165,46 @@ class Database {
   }
 
   /**
-   * Creates the database connection pool with 3 retry attempts on failure.
+   * Creates the database connection pool or SQLite instance with retries on failure.
    * @param {number} [retries=3] - Number of connection attempts.
-   * @returns {Promise<boolean>} True if connection pool was created.
+   * @returns {Promise<boolean>} True if connection was created.
    */
   async init(retries = 3) {
-    if (!mysqlPromise && !pgPromise) return false;
-    if (this.pool) return true;
+    if (!mysqlPromise && !pgPromise && !sqlitePromise) return false;
+    if (this.pool || this.db) return true;
+
+    if (this.type === "sqlite" && sqlitePromise) {
+      try {
+        const BetterSqlite = sqlitePromise.default || sqlitePromise;
+        const dbFilePath = path.isAbsolute(this.sqliteConfig.filename)
+          ? this.sqliteConfig.filename
+          : path.resolve(process.cwd(), this.sqliteConfig.filename);
+
+        const dir = path.dirname(dbFilePath);
+        if (!fs.existsSync(dir)) {
+          fs.mkdirSync(dir, { recursive: true });
+        }
+
+        this.db = new BetterSqlite(dbFilePath, {
+          timeout: this.sqliteConfig.busyTimeout,
+        });
+
+        this.db.pragma(`journal_mode = ${this.sqliteConfig.journalMode}`);
+        this.db.pragma(`synchronous = ${this.sqliteConfig.synchronous}`);
+        this.db.pragma("foreign_keys = ON");
+        this.db.pragma(`busy_timeout = ${this.sqliteConfig.busyTimeout}`);
+        this.db.pragma("temp_store = MEMORY");
+
+        return true;
+      } catch (err) {
+        console.error(
+          "[DATABASE ERROR] Failed to initialize SQLite database:",
+          err.message,
+        );
+        this.db = null;
+        return false;
+      }
+    }
 
     for (let attempt = 1; attempt <= retries; attempt++) {
       try {
@@ -138,7 +235,7 @@ class Database {
 
   /**
    * Runs a SQL query with parameters and formatting options.
-   * Supports both MySQL and PostgreSQL (converting ? to $1, $2 for Postgres automatically).
+   * Supports SQLite, MySQL, and PostgreSQL (converting ? to $1, $2 for Postgres automatically).
    *
    * @param {string} sql - SQL query string.
    * @param {Array} [params=[]] - Query parameter array.
@@ -150,8 +247,8 @@ class Database {
    * @example const insert_id = await connection.query("INSERT INTO users (name, email, password) VALUES (?, ?, ?)", ["John Doe", "john@example.com", "password"]);
    */
   async query(sql, params = [], options = {}) {
-    if (!mysqlPromise && !pgPromise) return false;
-    if (!this.pool) {
+    if (!mysqlPromise && !pgPromise && !sqlitePromise) return false;
+    if (!this.pool && !this.db) {
       const initialized = await this.init();
       if (!initialized) return false;
     }
@@ -159,8 +256,8 @@ class Database {
     const queryOptions =
       typeof options === "string" ? { [options]: true } : options;
     const cleanSql = sql.trim();
-    const isSelect = cleanSql.toLowerCase().startsWith("select");
-    const isInsert = cleanSql.toLowerCase().startsWith("insert");
+    const isSelect = /^(select|pragma|explain)/i.test(cleanSql);
+    const isInsert = /^insert/i.test(cleanSql);
 
     const redisClient = getRedisClient();
     let cacheKey = null;
@@ -201,7 +298,42 @@ class Database {
     }
 
     try {
-      if (this.type === "postgres" && pgPromise) {
+      if (this.type === "sqlite" && this.db) {
+        const stmt = this.db.prepare(cleanSql);
+
+        if (isSelect) {
+          if (queryOptions.return_row) {
+            const row = stmt.get(...params);
+            const result = row || null;
+            if (cacheKey && queryOptions.cache && redisClient) {
+              await redisClient
+                .set(cacheKey, JSON.stringify(result), {
+                  EX: parseInt(queryOptions.cache),
+                })
+                .catch(() => {});
+            }
+            return result;
+          }
+
+          const rows = stmt.all(...params);
+          if (cacheKey && queryOptions.cache && redisClient) {
+            await redisClient
+              .set(cacheKey, JSON.stringify(rows), {
+                EX: parseInt(queryOptions.cache),
+              })
+              .catch(() => {});
+          }
+          return rows;
+        }
+
+        if (isInsert) {
+          const info = stmt.run(...params);
+          return Number(info.lastInsertRowid);
+        }
+
+        const info = stmt.run(...params);
+        return info.changes;
+      } else if (this.type === "postgres" && pgPromise) {
         let paramIndex = 1;
         const pgSql = cleanSql.replace(/\?/g, () => `$${paramIndex++}`);
         const res = await this.pool.query(pgSql, params);
@@ -305,13 +437,48 @@ class Database {
    * });
    */
   async transaction(callback) {
-    if (!mysqlPromise && !pgPromise) throw new Error("[DATABASE ERROR] No database driver available.");
-    if (!this.pool) {
+    if (!mysqlPromise && !pgPromise && !sqlitePromise) throw new Error("[DATABASE ERROR] No database driver available.");
+    if (!this.pool && !this.db) {
       const initialized = await this.init();
       if (!initialized) throw new Error("[DATABASE ERROR] Failed to initialize database pool.");
     }
 
-    if (this.type === "postgres" && pgPromise) {
+    if (this.type === "sqlite" && this.db) {
+      this.db.exec("BEGIN IMMEDIATE");
+      try {
+        const tx = {
+          query: async (sql, params = [], options = {}) => {
+            const queryOptions = typeof options === "string" ? { [options]: true } : options;
+            const cleanSql = sql.trim();
+            const isSelect = /^(select|pragma|explain)/i.test(cleanSql);
+            const isInsert = /^insert/i.test(cleanSql);
+
+            const stmt = this.db.prepare(cleanSql);
+            if (isSelect) {
+              if (queryOptions.return_row) {
+                const row = stmt.get(...params);
+                return row || null;
+              }
+              return stmt.all(...params);
+            }
+            if (isInsert) {
+              const info = stmt.run(...params);
+              return Number(info.lastInsertRowid);
+            }
+            const info = stmt.run(...params);
+            return info.changes;
+          }
+        };
+
+        const result = await callback(tx);
+        this.db.exec("COMMIT");
+        return result;
+      } catch (err) {
+        this.db.exec("ROLLBACK");
+        console.error("[DATABASE ERROR] Transaction rolled back:", err.message);
+        throw err;
+      }
+    } else if (this.type === "postgres" && pgPromise) {
       const client = await this.pool.connect();
       try {
         await client.query("BEGIN");
@@ -394,6 +561,24 @@ class Database {
   async executeTransaction(callback) {
     return this.transaction(callback);
   }
+
+  /**
+   * Closes the database connection pool or SQLite instance.
+   */
+  async close() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+    }
+    if (this.pool) {
+      if (typeof this.pool.end === "function") {
+        await this.pool.end();
+      }
+      this.pool = null;
+    }
+  }
 }
 
 export { Database, DB_TYPE };
+
+