deploy-bbc 1.2.4 → 1.3.0

package/dist/templates/base-express/src/controllers/user/update-user.controller.ts

@@ -0,0 +1,102 @@
+import type { Request, Response } from "express";
+import { z } from "zod";
+import { user_model } from "../../models/user.model.js";
+import type { ApiResponse, ApiError } from "../../types/common/api-response.types.js";
+import type { UserResponse } from "../../types/models/user.types.js";
+
+/**
+ * Validation schemas
+ */
+const user_id_schema = z.string().uuid("Invalid user ID format");
+const update_user_schema = z.object({
+  email: z.string().email("Invalid email address").optional(),
+  name: z.string().min(2, "Name must be at least 2 characters").max(100, "Name must not exceed 100 characters").optional(),
+});
+
+/**
+ * Helper to format user response
+ */
+function format_user_response(user: any): UserResponse {
+  return {
+    id: user.id,
+    email: user.email,
+    name: user.name,
+    createdAt: user.createdAt.toISOString(),
+    updatedAt: user.updatedAt.toISOString(),
+  };
+}
+
+/**
+ * Update user by ID
+ * PATCH /users/:id
+ */
+export async function update_user(req: Request, res: Response) {
+  try {
+    const { id } = req.params;
+
+    // Validate ID format
+    const id_validation = user_id_schema.safeParse(id);
+    if (!id_validation.success) {
+      const errorResponse: ApiError = {
+        success: false,
+        error: "Invalid user ID",
+        details: id_validation.error.errors.map((err) => ({
+          field: err.path.join("."),
+          message: err.message,
+        })),
+      };
+      return res.status(400).json(errorResponse);
+    }
+
+    // Validate request body
+    const body_validation = update_user_schema.safeParse(req.body);
+    if (!body_validation.success) {
+      const errorResponse: ApiError = {
+        success: false,
+        error: "Validation failed",
+        details: body_validation.error.errors.map((err) => ({
+          field: err.path.join("."),
+          message: err.message,
+        })),
+      };
+      return res.status(400).json(errorResponse);
+    }
+
+    // Check if email is being updated and if it already exists
+    if (body_validation.data.email) {
+      const existing_user = await user_model.find_by_email(body_validation.data.email);
+      if (existing_user && existing_user.id !== id) {
+        const errorResponse: ApiError = {
+          success: false,
+          error: "User with this email already exists",
+        };
+        return res.status(409).json(errorResponse);
+      }
+    }
+
+    // Update user
+    const user = await user_model.update(id, body_validation.data);
+
+    if (!user) {
+      const errorResponse: ApiError = {
+        success: false,
+        error: "User not found",
+      };
+      return res.status(404).json(errorResponse);
+    }
+
+    const response: ApiResponse<UserResponse> = {
+      success: true,
+      data: format_user_response(user),
+      message: "User updated successfully",
+    };
+
+    res.json(response);
+  } catch (error) {
+    const errorResponse: ApiError = {
+      success: false,
+      error: "Failed to update user",
+    };
+    res.status(500).json(errorResponse);
+  }
+}

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

@@ -0,0 +1,83 @@
+import type { User, CreateUserInput, UpdateUserInput } from "../types/models/user.types.js";
+
+/**
+ * User model
+ *
+ * This is a simple in-memory implementation.
+ * Replace with your actual database implementation in production.
+ */
+
+// In-memory storage (for demonstration)
+const users: User[] = [];
+
+export const user_model = {
+  /**
+   * Find all users
+   */
+  find_all: async (): Promise<User[]> => {
+    return users;
+  },
+
+  /**
+   * Find user by ID
+   */
+  find_by_id: async (id: string): Promise<User | undefined> => {
+    return users.find((user) => user.id === id);
+  },
+
+  /**
+   * Find user by email
+   */
+  find_by_email: async (email: string): Promise<User | undefined> => {
+    return users.find((user) => user.email === email);
+  },
+
+  /**
+   * Create a new user
+   */
+  create: async (input: CreateUserInput): Promise<User> => {
+    const user: User = {
+      id: crypto.randomUUID(),
+      email: input.email,
+      name: input.name,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+
+    users.push(user);
+    return user;
+  },
+
+  /**
+   * Update user by ID
+   */
+  update: async (id: string, input: UpdateUserInput): Promise<User | undefined> => {
+    const index = users.findIndex((user) => user.id === id);
+
+    if (index === -1) {
+      return undefined;
+    }
+
+    users[index] = {
+      ...users[index],
+      ...input,
+      updatedAt: new Date(),
+    };
+
+    return users[index];
+  },
+
+  /**
+   * Delete user by ID
+   */
+  delete: async (id: string): Promise<boolean> => {
+    const index = users.findIndex((user) => user.id === id);
+
+    if (index === -1) {
+      return false;
+    }
+
+    users.splice(index, 1);
+    return true;
+  },
+};

package/dist/templates/base-express/src/routes/index.ts

@@ -1,7 +1,9 @@
 import express from "express";
+import user_route from "./user.route.js";
 
 const router = express.Router();
 
+// Root route
 router.get("/", (req, res) => {
   res.json({
     message: "Welcome to your Bun backend!",
@@ -9,4 +11,7 @@ router.get("/", (req, res) => {
   });
 });
 
+// User routes
+router.use("/users", user_route);
+
 export default router;

package/dist/templates/base-express/src/routes/user.route.ts

@@ -0,0 +1,17 @@
+import express from "express";
+import { get_users } from "../controllers/user/get-users.controller.js";
+import { get_user } from "../controllers/user/get-user.controller.js";
+import { create_user } from "../controllers/user/create-user.controller.js";
+import { update_user } from "../controllers/user/update-user.controller.js";
+import { delete_user } from "../controllers/user/delete-user.controller.js";
+
+const user_route = express.Router();
+
+// User CRUD routes
+user_route.get("/", get_users);
+user_route.get("/:id", get_user);
+user_route.post("/", create_user);
+user_route.patch("/:id", update_user);
+user_route.delete("/:id", delete_user);
+
+export default user_route;

package/dist/templates/base-express/src/types/common/api-response.types.ts

@@ -0,0 +1,30 @@
+/**
+ * Common API response types
+ */
+
+export interface ApiResponse<T = unknown> {
+  success: boolean;
+  data?: T;
+  error?: string;
+  message?: string;
+}
+
+export interface PaginatedResponse<T> extends ApiResponse<T[]> {
+  pagination: {
+    page: number;
+    limit: number;
+    total: number;
+    totalPages: number;
+  };
+}
+
+export interface ValidationError {
+  field: string;
+  message: string;
+}
+
+export interface ApiError {
+  success: false;
+  error: string;
+  details?: ValidationError[];
+}

package/dist/templates/base-express/src/types/index.ts

@@ -1,2 +1,5 @@
-// Add your TypeScript types and interfaces here
-export {};
+// Export common types
+export * from "./common/api-response.types.js";
+
+// Export model types
+export * from "./models/user.types.js";

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

@@ -0,0 +1,26 @@
+/**
+ * User model types
+ */
+
+export interface User {
+  id: string;
+  email: string;
+  name: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface CreateUserInput {
+  email: string;
+  name: string;
+}
+
+export interface UpdateUserInput {
+  email?: string;
+  name?: string;
+}
+
+export type UserResponse = Omit<User, "createdAt" | "updatedAt"> & {
+  createdAt: string;
+  updatedAt: string;
+};

package/dist/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 };

package/dist/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/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/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}`;
+}
+*/