deploy-bbc 1.2.3 → 1.3.0

package/dist/templates/templates/extras/database/mongodb/src/db/models/user.model.ts

@@ -0,0 +1,87 @@
+import { Schema, model, Document } from "mongoose";
+
+/**
+ * User interface for TypeScript
+ */
+export type User = {
+  email: string;
+  name: string;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+/**
+ * User document interface (Mongoose Document + User)
+ */
+export type UserDocument = Document & User;
+
+/**
+ * User schema definition
+ */
+const user_schema = new Schema<UserDocument>(
+  {
+    email: {
+      type: String,
+      required: [true, "Email is required"],
+      unique: true,
+      lowercase: true,
+      trim: true,
+      match: [/^\S+@\S+\.\S+$/, "Please provide a valid email"],
+    },
+    name: {
+      type: String,
+      required: [true, "Name is required"],
+      trim: true,
+      minlength: [2, "Name must be at least 2 characters"],
+      maxlength: [100, "Name cannot exceed 100 characters"],
+    },
+  },
+  {
+    timestamps: true, // Automatically add createdAt and updatedAt
+    versionKey: false, // Disable __v field
+  }
+);
+
+/**
+ * Indexes for better query performance
+ */
+user_schema.index({ email: 1 });
+
+/**
+ * User model
+ */
+export const user_model = model<UserDocument>("User", user_schema);
+
+// Example usage functions
+/*
+// Create a new user
+export async function create_user(email: string, name: string) {
+  const user = new user_model({ email, name });
+  return await user.save();
+}
+
+// Find all users
+export async function find_all_users() {
+  return await user_model.find();
+}
+
+// Find user by ID
+export async function find_user_by_id(id: string) {
+  return await user_model.findById(id);
+}
+
+// Find user by email
+export async function find_user_by_email(email: string) {
+  return await user_model.findOne({ email });
+}
+
+// Update user
+export async function update_user(id: string, data: Partial<User>) {
+  return await user_model.findByIdAndUpdate(id, data, { new: true });
+}
+
+// Delete user
+export async function delete_user(id: string) {
+  return await user_model.findByIdAndDelete(id);
+}
+*/

package/dist/templates/templates/extras/database/mysql/src/db/index.ts

@@ -0,0 +1,106 @@
+import mysql from "mysql2/promise";
+
+/**
+ * MySQL database connection using mysql2 (optimized for Bun)
+ * Docs: https://github.com/sidorares/node-mysql2
+ * Note: mysql2 works natively with Bun and provides excellent performance
+ */
+
+const DATABASE_URL = process.env.DATABASE_URL;
+
+if (!DATABASE_URL) {
+  throw new Error("DATABASE_URL environment variable is required");
+}
+
+/**
+ * Create MySQL connection pool
+ * Supports automatic reconnection and connection reuse
+ */
+export const pool = mysql.createPool({
+  uri: DATABASE_URL,
+  waitForConnections: true,
+  connectionLimit: 10, // Maximum number of connections
+  queueLimit: 0, // Unlimited queueing
+  enableKeepAlive: true,
+  keepAliveInitialDelay: 0,
+});
+
+/**
+ * Get a connection from the pool for executing queries
+ * Use this for single queries or simple operations
+ */
+export async function query(sql: string, params?: any[]) {
+  const [rows] = await pool.execute(sql, params);
+  return rows;
+}
+
+/**
+ * Test database connection
+ */
+export async function test_connection(): Promise<boolean> {
+  try {
+    await pool.query("SELECT 1");
+    console.log("✅ MySQL connected successfully");
+    return true;
+  } catch (error) {
+    console.error("❌ MySQL connection failed:", error);
+    return false;
+  }
+}
+
+/**
+ * Close database connection pool
+ * Call this when shutting down the application
+ */
+export async function close_connection(): Promise<void> {
+  await pool.end();
+  console.log("MySQL connection pool closed");
+}
+
+// Example queries - uncomment and modify as needed
+/*
+// Create users table
+export async function create_users_table() {
+  await query(`
+    CREATE TABLE IF NOT EXISTS users (
+      id INT AUTO_INCREMENT PRIMARY KEY,
+      email VARCHAR(255) UNIQUE NOT NULL,
+      name VARCHAR(255) NOT NULL,
+      created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+      updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+    )
+  `);
+}
+
+// Get all users
+export async function get_all_users() {
+  return await query("SELECT * FROM users");
+}
+
+// Get user by ID
+export async function get_user_by_id(id: number) {
+  return await query("SELECT * FROM users WHERE id = ?", [id]);
+}
+
+// Create user
+export async function create_user(email: string, name: string) {
+  const result = await query(
+    "INSERT INTO users (email, name) VALUES (?, ?)",
+    [email, name]
+  );
+  return result;
+}
+
+// Update user
+export async function update_user(id: number, email: string, name: string) {
+  return await query(
+    "UPDATE users SET email = ?, name = ? WHERE id = ?",
+    [email, name, id]
+  );
+}
+
+// Delete user
+export async function delete_user(id: number) {
+  return await query("DELETE FROM users WHERE id = ?", [id]);
+}
+*/

package/dist/templates/templates/extras/database/postgres/src/db/index.ts

@@ -0,0 +1,96 @@
+import postgres from "postgres";
+
+/**
+ * PostgreSQL database connection using the native postgres driver
+ * Docs: https://github.com/porsager/postgres
+ */
+
+const DATABASE_URL = process.env.DATABASE_URL;
+
+if (!DATABASE_URL) {
+  throw new Error("DATABASE_URL environment variable is required");
+}
+
+/**
+ * Create PostgreSQL connection instance
+ * Supports connection pooling and automatic reconnection
+ */
+export const sql = postgres(DATABASE_URL, {
+  max: 10, // Maximum number of connections in the pool
+  idle_timeout: 20, // Idle connection timeout in seconds
+  connect_timeout: 10, // Connection timeout in seconds
+  onnotice: () => {}, // Suppress notices
+});
+
+/**
+ * Test database connection
+ */
+export async function test_connection(): Promise<boolean> {
+  try {
+    await sql`SELECT 1`;
+    console.log("✅ PostgreSQL connected successfully");
+    return true;
+  } catch (error) {
+    console.error("❌ PostgreSQL connection failed:", error);
+    return false;
+  }
+}
+
+/**
+ * Close database connection
+ * Call this when shutting down the application
+ */
+export async function close_connection(): Promise<void> {
+  await sql.end({ timeout: 5 });
+  console.log("PostgreSQL connection closed");
+}
+
+// Example queries - uncomment and modify as needed
+/*
+// Create users table
+export async function create_users_table() {
+  await sql`
+    CREATE TABLE IF NOT EXISTS users (
+      id SERIAL PRIMARY KEY,
+      email VARCHAR(255) UNIQUE NOT NULL,
+      name VARCHAR(255) NOT NULL,
+      created_at TIMESTAMP DEFAULT NOW(),
+      updated_at TIMESTAMP DEFAULT NOW()
+    )
+  `;
+}
+
+// Get all users
+export async function get_all_users() {
+  return await sql`SELECT * FROM users`;
+}
+
+// Get user by ID
+export async function get_user_by_id(id: number) {
+  return await sql`SELECT * FROM users WHERE id = ${id}`;
+}
+
+// Create user
+export async function create_user(email: string, name: string) {
+  return await sql`
+    INSERT INTO users (email, name)
+    VALUES (${email}, ${name})
+    RETURNING *
+  `;
+}
+
+// Update user
+export async function update_user(id: number, email: string, name: string) {
+  return await sql`
+    UPDATE users
+    SET email = ${email}, name = ${name}, updated_at = NOW()
+    WHERE id = ${id}
+    RETURNING *
+  `;
+}
+
+// Delete user
+export async function delete_user(id: number) {
+  return await sql`DELETE FROM users WHERE id = ${id}`;
+}
+*/

package/dist/templates/templates/extras/database/redis/src/db/redis.ts

@@ -0,0 +1,215 @@
+import { createClient } from "redis";
+
+/**
+ * Redis client setup
+ * Docs: https://github.com/redis/node-redis
+ */
+
+const REDIS_URL = process.env.REDIS_URL || "redis://localhost:6379";
+
+/**
+ * Create Redis client instance
+ */
+export const redis_client = createClient({
+  url: REDIS_URL,
+  socket: {
+    reconnectStrategy: (retries) => {
+      if (retries > 10) {
+        console.error("❌ Redis connection failed after 10 retries");
+        return new Error("Redis connection failed");
+      }
+      // Exponential backoff: 50ms, 100ms, 200ms, etc.
+      return Math.min(retries * 50, 3000);
+    },
+  },
+});
+
+/**
+ * Connect to Redis
+ */
+export async function connect_redis(): Promise<void> {
+  try {
+    await redis_client.connect();
+    console.log("✅ Redis connected successfully");
+  } catch (error) {
+    console.error("❌ Redis connection failed:", error);
+    throw error;
+  }
+}
+
+/**
+ * Disconnect from Redis
+ * Call this when shutting down the application
+ */
+export async function disconnect_redis(): Promise<void> {
+  await redis_client.quit();
+  console.log("Redis connection closed");
+}
+
+/**
+ * Test Redis connection
+ */
+export async function test_connection(): Promise<boolean> {
+  try {
+    await redis_client.ping();
+    console.log("✅ Redis ping successful");
+    return true;
+  } catch (error) {
+    console.error("❌ Redis ping failed:", error);
+    return false;
+  }
+}
+
+// Event listeners
+redis_client.on("error", (err) => {
+  console.error("Redis Client Error:", err);
+});
+
+redis_client.on("connect", () => {
+  console.log("Redis client connected");
+});
+
+redis_client.on("ready", () => {
+  console.log("Redis client ready");
+});
+
+redis_client.on("reconnecting", () => {
+  console.log("Redis client reconnecting...");
+});
+
+// Helper functions for common operations
+export const redis = {
+  /**
+   * Set a key-value pair
+   */
+  set: async (key: string, value: string, expireSeconds?: number) => {
+    if (expireSeconds) {
+      return await redis_client.setEx(key, expireSeconds, value);
+    }
+    return await redis_client.set(key, value);
+  },
+
+  /**
+   * Get value by key
+   */
+  get: async (key: string) => {
+    return await redis_client.get(key);
+  },
+
+  /**
+   * Delete a key
+   */
+  del: async (key: string) => {
+    return await redis_client.del(key);
+  },
+
+  /**
+   * Check if key exists
+   */
+  exists: async (key: string) => {
+    return await redis_client.exists(key);
+  },
+
+  /**
+   * Set expiration on a key
+   */
+  expire: async (key: string, seconds: number) => {
+    return await redis_client.expire(key, seconds);
+  },
+
+  /**
+   * Get all keys matching pattern
+   */
+  keys: async (pattern: string) => {
+    return await redis_client.keys(pattern);
+  },
+
+  /**
+   * Increment a value
+   */
+  incr: async (key: string) => {
+    return await redis_client.incr(key);
+  },
+
+  /**
+   * Decrement a value
+   */
+  decr: async (key: string) => {
+    return await redis_client.decr(key);
+  },
+
+  /**
+   * Hash operations
+   */
+  hash: {
+    set: async (key: string, field: string, value: string) => {
+      return await redis_client.hSet(key, field, value);
+    },
+    get: async (key: string, field: string) => {
+      return await redis_client.hGet(key, field);
+    },
+    getAll: async (key: string) => {
+      return await redis_client.hGetAll(key);
+    },
+    del: async (key: string, field: string) => {
+      return await redis_client.hDel(key, field);
+    },
+  },
+
+  /**
+   * List operations
+   */
+  list: {
+    push: async (key: string, ...values: string[]) => {
+      return await redis_client.lPush(key, values);
+    },
+    pop: async (key: string) => {
+      return await redis_client.lPop(key);
+    },
+    range: async (key: string, start: number, stop: number) => {
+      return await redis_client.lRange(key, start, stop);
+    },
+    length: async (key: string) => {
+      return await redis_client.lLen(key);
+    },
+  },
+
+  /**
+   * Set operations
+   */
+  set_ops: {
+    add: async (key: string, ...members: string[]) => {
+      return await redis_client.sAdd(key, members);
+    },
+    members: async (key: string) => {
+      return await redis_client.sMembers(key);
+    },
+    isMember: async (key: string, member: string) => {
+      return await redis_client.sIsMember(key, member);
+    },
+    remove: async (key: string, ...members: string[]) => {
+      return await redis_client.sRem(key, members);
+    },
+  },
+};
+
+// Example usage:
+/*
+// Simple key-value
+await redis.set("user:1:name", "John Doe");
+await redis.set("session:abc123", "user_data", 3600); // Expires in 1 hour
+const name = await redis.get("user:1:name");
+
+// Hash (for objects)
+await redis.hash.set("user:1", "email", "john@example.com");
+await redis.hash.set("user:1", "age", "30");
+const userData = await redis.hash.getAll("user:1");
+
+// Lists (queues)
+await redis.list.push("tasks", "task1", "task2");
+const task = await redis.list.pop("tasks");
+
+// Sets (unique values)
+await redis.set_ops.add("online_users", "user1", "user2");
+const isOnline = await redis.set_ops.isMember("online_users", "user1");
+*/

package/dist/templates/templates/extras/database/sqlite/src/db/index.ts

@@ -0,0 +1,185 @@
+import { Database } from "bun:sqlite";
+
+/**
+ * SQLite database connection using Bun's built-in sqlite module
+ * Docs: https://bun.sh/docs/api/sqlite
+ *
+ * Benefits of bun:sqlite:
+ * - Zero dependencies (built into Bun)
+ * - Extremely fast (native implementation)
+ * - Type-safe prepared statements
+ * - Automatic statement caching
+ */
+
+const DATABASE_PATH = process.env.DATABASE_PATH || "./data/app.db";
+
+/**
+ * Create SQLite database instance
+ * Options:
+ * - create: true - creates the database file if it doesn't exist
+ * - readwrite: allows both reading and writing
+ * - strict: enables strict mode for better type safety
+ */
+export const db = new Database(DATABASE_PATH, {
+  create: true,
+  readwrite: true,
+  strict: true,
+});
+
+// Enable Write-Ahead Logging (WAL) mode for better concurrency
+db.run("PRAGMA journal_mode = WAL");
+
+// Enable foreign key constraints
+db.run("PRAGMA foreign_keys = ON");
+
+/**
+ * Test database connection
+ */
+export function test_connection(): boolean {
+  try {
+    const result = db.query("SELECT 1 as test").get() as { test: number };
+    console.log("✅ SQLite connected successfully");
+    return result.test === 1;
+  } catch (error) {
+    console.error("❌ SQLite connection failed:", error);
+    return false;
+  }
+}
+
+/**
+ * Close database connection
+ * Call this when shutting down the application
+ */
+export function close_connection(): void {
+  db.close();
+  console.log("SQLite connection closed");
+}
+
+/**
+ * Helper function to run migrations/DDL statements
+ */
+export function migrate(sql: string): void {
+  db.run(sql);
+}
+
+// Example usage - uncomment and modify as needed
+/*
+// Create users table
+export function create_users_table() {
+  db.run(`
+    CREATE TABLE IF NOT EXISTS users (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      email TEXT UNIQUE NOT NULL,
+      name TEXT NOT NULL,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+      updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    )
+  `);
+
+  // Create index on email
+  db.run(`CREATE INDEX IF NOT EXISTS idx_users_email ON users(email)`);
+}
+
+// Get all users
+export function get_all_users() {
+  return db.query("SELECT * FROM users").all();
+}
+
+// Get user by ID
+export function get_user_by_id(id: number) {
+  const stmt = db.query("SELECT * FROM users WHERE id = ?");
+  return stmt.get(id);
+}
+
+// Get user by email
+export function get_user_by_email(email: string) {
+  const stmt = db.query("SELECT * FROM users WHERE email = ?");
+  return stmt.get(email);
+}
+
+// Create user
+export function create_user(email: string, name: string) {
+  const stmt = db.prepare(`
+    INSERT INTO users (email, name)
+    VALUES (?, ?)
+  `);
+
+  const result = stmt.run(email, name);
+  return {
+    id: result.lastInsertRowid,
+    email,
+    name,
+  };
+}
+
+// Update user
+export function update_user(id: number, email: string, name: string) {
+  const stmt = db.prepare(`
+    UPDATE users
+    SET email = ?, name = ?, updated_at = CURRENT_TIMESTAMP
+    WHERE id = ?
+  `);
+
+  stmt.run(email, name, id);
+  return get_user_by_id(id);
+}
+
+// Delete user
+export function delete_user(id: number) {
+  const stmt = db.prepare("DELETE FROM users WHERE id = ?");
+  const result = stmt.run(id);
+  return result.changes > 0;
+}
+
+// Transaction example
+export function create_user_with_profile(
+  email: string,
+  name: string,
+  bio: string
+) {
+  const transaction = db.transaction((email, name, bio) => {
+    // Create user
+    const userStmt = db.prepare("INSERT INTO users (email, name) VALUES (?, ?)");
+    const userResult = userStmt.run(email, name);
+    const userId = userResult.lastInsertRowid;
+
+    // Create profile
+    const profileStmt = db.prepare("INSERT INTO profiles (user_id, bio) VALUES (?, ?)");
+    profileStmt.run(userId, bio);
+
+    return userId;
+  });
+
+  return transaction(email, name, bio);
+}
+
+// Batch insert example
+export function create_users_batch(users: Array<{ email: string; name: string }>) {
+  const stmt = db.prepare("INSERT INTO users (email, name) VALUES (?, ?)");
+
+  const insertMany = db.transaction((users) => {
+    for (const user of users) {
+      stmt.run(user.email, user.name);
+    }
+  });
+
+  insertMany(users);
+}
+
+// Type-safe query example
+type User = {
+  id: number;
+  email: string;
+  name: string;
+  created_at: string;
+  updated_at: string;
+}
+
+export function get_users_typed(): User[] {
+  return db.query<User, []>("SELECT * FROM users").all();
+}
+
+export function get_user_by_id_typed(id: number): User | null {
+  return db.query<User, [number]>("SELECT * FROM users WHERE id = ?").get(id);
+}
+*/

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "deploy-bbc",
-    "version": "1.2.3",
+    "version": "1.3.0",
     "description": "CLI to bootstrap production-ready backends with Bun (Best Backend Code)",
     "type": "module",
     "bin": {