deploy-bbc 1.2.3 → 1.3.0

package/dist/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/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/dist/templates/templates/base/.dockerignore

@@ -0,0 +1,45 @@
+# Dependencies
+node_modules
+
+# Environment variables
+.env
+.env.local
+.env.*.local
+
+# Build artifacts
+dist
+*.log
+
+# Development
+.git
+.gitignore
+README.md
+.vscode
+.idea
+
+# Testing
+coverage
+*.test.ts
+*.spec.ts
+
+# Docker
+Dockerfile
+docker-compose.yml
+.dockerignore
+
+# OS
+.DS_Store
+Thumbs.db
+
+# SQLite databases (if using SQLite)
+*.db
+*.sqlite
+*.sqlite3
+data/*.db
+
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*

package/dist/templates/templates/base/src/models/user.model.ts

@@ -4,7 +4,7 @@ import type { User, CreateUserInput, UpdateUserInput } from "../types/models/use
  * User model
  *
  * This is a simple in-memory implementation.
- * Replace with your database ORM (Drizzle, Prisma, etc.) in production.
+ * Replace with your actual database implementation in production.
  */
 
 // In-memory storage (for demonstration)

package/dist/templates/templates/base-bun-native/.dockerignore

@@ -0,0 +1,45 @@
+# Dependencies
+node_modules
+
+# Environment variables
+.env
+.env.local
+.env.*.local
+
+# Build artifacts
+dist
+*.log
+
+# Development
+.git
+.gitignore
+README.md
+.vscode
+.idea
+
+# Testing
+coverage
+*.test.ts
+*.spec.ts
+
+# Docker
+Dockerfile
+docker-compose.yml
+.dockerignore
+
+# OS
+.DS_Store
+Thumbs.db
+
+# SQLite databases (if using SQLite)
+*.db
+*.sqlite
+*.sqlite3
+data/*.db
+
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*

package/dist/templates/templates/base-bun-native/src/models/user.model.ts

@@ -4,7 +4,7 @@ import type { User, CreateUserInput, UpdateUserInput } from "../types/models/use
  * User model
  *
  * This is a simple in-memory implementation.
- * Replace with your database ORM (Drizzle, Prisma, etc.) in production.
+ * Replace with your actual database implementation in production.
  */
 
 // In-memory storage (for demonstration)

package/dist/templates/templates/base-express/.dockerignore

@@ -0,0 +1,45 @@
+# Dependencies
+node_modules
+
+# Environment variables
+.env
+.env.local
+.env.*.local
+
+# Build artifacts
+dist
+*.log
+
+# Development
+.git
+.gitignore
+README.md
+.vscode
+.idea
+
+# Testing
+coverage
+*.test.ts
+*.spec.ts
+
+# Docker
+Dockerfile
+docker-compose.yml
+.dockerignore
+
+# OS
+.DS_Store
+Thumbs.db
+
+# SQLite databases (if using SQLite)
+*.db
+*.sqlite
+*.sqlite3
+data/*.db
+
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*

package/dist/templates/templates/base-express/src/models/user.model.ts

@@ -4,7 +4,7 @@ import type { User, CreateUserInput, UpdateUserInput } from "../types/models/use
  * User model
  *
  * This is a simple in-memory implementation.
- * Replace with your database ORM (Drizzle, Prisma, etc.) in production.
+ * Replace with your actual database implementation in production.
  */
 
 // In-memory storage (for demonstration)

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

@@ -0,0 +1,70 @@
+import mongoose from "mongoose";
+
+/**
+ * MongoDB database connection using Mongoose
+ * Docs: https://mongoosejs.com/docs/connections.html
+ */
+
+const MONGODB_URI = process.env.MONGODB_URI;
+
+if (!MONGODB_URI) {
+  throw new Error("MONGODB_URI environment variable is required");
+}
+
+/**
+ * Connect to MongoDB
+ */
+export async function connect_mongodb(): Promise<void> {
+  try {
+    await mongoose.connect(MONGODB_URI, {
+      maxPoolSize: 10, // Maximum number of connections in the pool
+      minPoolSize: 2, // Minimum number of connections
+      serverSelectionTimeoutMS: 5000, // Timeout for initial connection
+      socketTimeoutMS: 45000, // Socket timeout
+    });
+    console.log("✅ MongoDB connected successfully");
+  } catch (error) {
+    console.error("❌ MongoDB connection failed:", error);
+    throw error;
+  }
+}
+
+/**
+ * Disconnect from MongoDB
+ * Call this when shutting down the application
+ */
+export async function disconnect_mongodb(): Promise<void> {
+  await mongoose.disconnect();
+  console.log("MongoDB connection closed");
+}
+
+/**
+ * Test database connection
+ */
+export async function test_connection(): Promise<boolean> {
+  try {
+    if (mongoose.connection.readyState !== 1) {
+      await connect_mongodb();
+    }
+    return true;
+  } catch (error) {
+    console.error("❌ MongoDB connection test failed:", error);
+    return false;
+  }
+}
+
+// Connection event listeners
+mongoose.connection.on("connected", () => {
+  console.log("Mongoose connected to MongoDB");
+});
+
+mongoose.connection.on("error", (err) => {
+  console.error("Mongoose connection error:", err);
+});
+
+mongoose.connection.on("disconnected", () => {
+  console.log("Mongoose disconnected from MongoDB");
+});
+
+// Export mongoose instance for model creation
+export { mongoose };